package main

import (
  "fmt"
)

// 定義struct
type Human struct {
  name string
  age  int
  phone string
}
type Student struct {
  Human // 匿名字段
  school string
  loan  float32
}
type Employee struct {
  Human  // 匿名字段
  company string
  money  float32
}

// Human對象實現SayHi()方法
func (h Human) SayHi() {
  fmt.Printf("Hi, I am %s, you can call me on %s\n", h.name, h.phone)
}

// Human對象實現Sing()方法
func (h Human) Sing(lyrics string) {
  fmt.Println("La la la...", lyrics)
}

// Human對象實現Guzzle()方法
func (h Human) Guzzle(beerStein string) {
  fmt.Println("Guzzle Guzzle Guzzle...", beerStein)
}

// Employee對象重寫SayHi()方法
func (e Employee) SayHi() {
  fmt.Printf("Hi I am %s, I work at %s. Call me on %s\n", e.name, e.company, e.phone)
}

// Student對象實現BorrowMoney()方法
func (s Student) BorrowMoney(amount float32) {
  s.loan += amount
}

// Employee對象實現SpendSalary()方法
func (e Employee) SpendSalary(amount float32) {
  e.money -= amount
}

// 定義interface，interface是一組method簽名的組合
// interface可以被任意對象實現，一個對象也可以實現多個interface
// 任意類型都實現了空interface（也就是包含0個method的interface）
// 空interface可以存儲任意類型的值
// interface Men的3個method被Human,Student,Employee實現，也就是這3個對象都實現了interface Men。即：
// interface定義了一組方法，如果某個對象實現了某個接口的所有方法，則此對象就實現了此接口。
type Men interface {
  SayHi()
  Sing(lyrice string)
  Guzzle(beerStein string)
}

// interface YoungChap的BorrowMoney() method只被Student對象實現，也就是只有Student實現了YoungChap
type YoungChap interface {
  SayHi()
  Sing(song string)
  BorrowMoney(amount float32)
}

// interface ElderlyGent的SpendSalary() method只被Employee對象實現，也就是只有Employee實現了ElderlyGent
type ElderlyGent interface {
  SayHi()
  Sing(song string)
  SpendSalary(amount float32)
}

func main() {
  // 定義Student類型的變量
  lucy := Student{Human{"lucy", 19, "10086"}, "tsinghua", 100.00}
  lily := Student{Human{"lily", 19, "10086"}, "tsinghua", 100.00}
  liming := Student{Human{"liming", 19, "10086"}, "tsinghua", 100.00}
  // 定義Employee類型的變量
  tom := Employee{Human{"tom", 29, "10000"}, "Google", 200.00}
  // 定義Men類型的變量i
  var i Men
  // i存儲Student
  i = lucy
  fmt.Println("This is lucy, a student:")
  i.SayHi()
  i.Sing("Happy Birthday")
  i.Guzzle("Ha ha ha...")

  // i存儲Employee
  i = tom
  fmt.Println("This is tom, an Employee:")
  i.SayHi()

  // 定義slice Men，包含Men類型元素的切片，這個slice可以被賦予實現了Men接口的任意結構的對象
  fmt.Println("Let's use a slice of Men and see what happens:")
  x := make([]Men, 3)
  // 三個不同類型（不同Method）的元素，實現了同一個interface（Men）
  x[0], x[1], x[2] = lucy, lily, liming
  for _, value := range x {
    value.SayHi()
  }
}

/**
 * interface接口作為函數參數
 * 判斷interface變量存儲的元素的類型
 */
package main

import (
  "fmt"
  "strconv"
)

// 定義Human對象
type Human struct {
  name string
  age  int 
  phone string
}

// 定義空接口
type Element interface{}

// 定義切片
type List []Element

// 定義Person對象
type Person struct {
  name string
  age int 
}

// 通過定義interface參數，讓函數接受各種類型的參數
// 通過這個Method（方法），Human對象實現了fmt.Stringer接口
// Stringer接口是fmt.Println()的參數，最終使得Human對象可以作為fmt.Println的參數被調用
func (h Human) String() string {
  return "" + h.name + " - " + strconv.Itoa(h.age) + " years - phone: " + h.phone + ">" 
}

// 通過定義interface參數，讓函數接受各種類型的參數
// 通過這個Method（方法），Person對象實現了fmt.Stringer接口
// Stringer接口是fmt.Println()的參數，最終使得Person對象可以作為fmt.Println的參數被調用
func (p Person) String() string {
  return "(name: " + p.name + " - age: " + strconv.Itoa(p.age) + " years)"
}

func main() {
  // interface作為函數的參數傳遞
  Lucy := Human{"Lucy", 29, "10086"}
  fmt.Println("This human is:", Lucy)

  list := make(List, 3)
  list[0] = 100
  list[1] = "Hello Golang!"
  list[2] = Person{"Lily", 19}

  // Comma-ok斷言
  for index, element := range list {
    // 判斷變量的類型 格式：value, ok = element(T)
    // value是interface變量的值，ok是bool類型，element是interface的變量，T是斷言的interface變量的類型
    if value, ok := element.(int); ok {
      fmt.Printf("list[%d] is an int and it's value is %d\n", index, value)
    } else if value, ok := element.(string); ok {
      fmt.Printf("list[%d] is a string and it's value is %s\n", index, value)
    } else if value, ok := element.(Person); ok {
      fmt.Printf("list[%d] is a Person and it's value is %s\n", index, value)
    } else {
      fmt.Printf("list[%d] is a different type\n", index)
    }
  }

  // switch
  for index, element := range list {
    // 注意：element.(type)語法不能在switch外的任何邏輯中使用
    switch value := element.(type) {
    case int:
      fmt.Printf("list[%d] is an int, it's value is %d\n", index, value)
    case string:
      fmt.Printf("list[%d] is a string, it's value is %s\n", index, value)
    case Person:
      fmt.Printf("list[%d] is a Person, it's value is %s\n", index, value)
    default:
      fmt.Printf("list[%d] is a differernt type", index)
    }
  }
}