type Cat struct {
  Name string
}
func (c Cat) Say() string { 
  return c.Name + "：喵喵喵" 
}
type Dog struct {
  Name string
}
func (d Dog) Say() string { 
  return d.Name + ": 汪汪汪" 
}
func main() {
    c := Cat{Name: "小白貓"} // 小白貓：喵喵喵
    fmt.Println(c.Say())
    d := Dog{"阿黃"}
    fmt.Println(d.Say()) // 阿黃: 汪汪汪
}
/*
小白貓：喵喵喵
阿黃: 汪汪汪
*/

//1.接口是一個規(guī)范
type Usber interface {
    getName() string
}
//2.如果接口里面有方法的話，必要要通過結(jié)構(gòu)體或者通過自定義類型實現(xiàn)這個接口
type Phone struct {
    Name string
}
type Computer struct {
    Brand string
}
func (c *Computer) getName() string {
    return c.Brand
}
//3.手機要實現(xiàn)usb接口的話必須得實現(xiàn)usb接口中的所有方法
func (p *Phone) getName() string {
    return p.Name
}
func main() {
    p := &Phone{
    Name: "華為手機",
    }
    c := &Computer{
    Brand: "聯(lián)想電腦",
    }
    var p1 Usber // golang中接口就是一個數(shù)據(jù)類型
    p1 = p // 表示手機實現(xiàn)Usb接口
    fmt.Println(p1.getName())
    //接口使用場景，處理相同類型的數(shù)據(jù)
    newName := transData(p)
    newName1 := transData(c)
    fmt.Println(newName, newName1)
    }
    func transData(usber Usber) string {
        name := usber.getName()
        return fmt.Sprintf("%s%s", name, "處理后")
}

//空接口作為函數(shù)的參數(shù)
func show(a interface{}) {
    fmt.Printf("值:%v 類型:%T\n", a, a) }
    func main() { 
    show(20) // 值:20 類型:int 
    show("你好golang") // 值:你好golang 類型:string 
    slice := []int{1, 2, 34, 4} 
    show(slice) // 值:[1 2 34 4] 類型:[]int 
    }

func test(a int, b ...interface{}) {
    for _, v := range b {
        fmt.Printf("%v,%T \n", v, v)
    }
}
func main() {
    test(1, "a", 22, []string{"1"})
}
a,string 
22,int 
[1],[]string 

func main() { 
    var slice = []interface{}{"張三", 20, true, 32.2}
    fmt.Println(slice) // [張三 20 true 32.2] 
}

func main() { // 空接口作為 map 值 
var studentInfo = make(map[string]interface{}) 
studentInfo["name"] = "張三" 
studentInfo["age"] = 18 studentInfo["married"] = false
fmt.Println(studentInfo) // [age:18 married:false name:張三] }

    var str interface{}
    str = "hello"
    str = str + "sss"  //這樣寫是會報錯的，因為空接口類型不是字符串類型，需要斷言轉(zhuǎn)化才可以

type test1 struct {
    name string
    age  int
}
func main() {
    var t interface{}
    //未斷言前沒有結(jié)構(gòu)體的特征，需要斷言轉(zhuǎn)化為結(jié)構(gòu)體指針
    t = &test1{
        name: "hh",
        age:  12,
    }
    v, ok := t.(*test1)  //這里其實就是做了一個類型轉(zhuǎn)化，這里的類型就變?yōu)閬斫Y(jié)構(gòu)體指針類型
    if ok {
        fmt.Printf("類型:%T 值:%#v\n", v, v)
    } else {
        fmt.Println("xxx")
    }
}
類型:*main.test1 值:&main.test1{name:"hh", age:12}

type Usb interface { 
    Start() 
    Stop() 
}
type Phone struct { 
Name string 
}
func (p Phone) Start() {
fmt.Println(p.Name, "開始工作") 
}
func (p Phone) Stop() {
fmt.Println("phone 停止") 
}
func main() { 
    phone1 := Phone{  // 一：實例化值類型 
    Name: "小米手機", 
    }
    var p1 Usb = phone1 //phone1 實現(xiàn)了 Usb 接口 phone1 是 Phone 類型 
    p1.Start() 
    
    phone2 := &Phone{ // 二：實例化指針類型 
      Name: "蘋果手機", 
    }
    var p2 Usb = phone2 //phone2 實現(xiàn)了 Usb 接口 phone2 是 *Phone 類型 
    p2.Start() //蘋果手機 開始工作 
}