go实战基础（一） - go实战interface（十二） - 《GO 开发知识笔记》

package main
import "fmt"
//接口是一个规范
type Usber interface {
    start()
    stop()
}
//如果接口里面有方法的话，必要要通过结构体或者通过自定义类型实现这个接口
type Phone struct {
    Name string
}
//手机要实现usb接口的话必须得实现usb接口中的所有方法
func (p Phone) start() {
    fmt.Println(p.Name, "启动")
}
func (p Phone) stop() {
    fmt.Println(p.Name, "关机")
}
type Camera struct {
}
func (p Camera) start() {
    fmt.Println("相机启动")
}
func (p Camera) stop() {
    fmt.Println("相机关机")
}
func (p Camera) run() {
    fmt.Println("run")
}
func main() {
    p := Phone{
        Name: "华为手机",
    }
    // p.start1()
    var p1 Usber //golang中接口就是一个数据类型
    p1 = p       //表示手机实现Usb接口
    p1.stop()
    c := Camera{}
    var c1 Usber = c //表示相机实现了Usb接口
    c1.start()
    // c1.run()  //错误：type Usber has no field or method run)
    c.run() //run
}

package main
import "fmt"
type Usber interface {
    start()
    stop()
}
//电脑
type Computer struct {
}
// var usb Usber =camera
func (c Computer) work(usb Usber) {
    usb.start()
    usb.stop()
}
//手机
type Phone struct {
    Name string
}
func (p Phone) start() {
    fmt.Println(p.Name, "启动")
}
func (p Phone) stop() {
    fmt.Println(p.Name, "关机")
}
//照相机
type Camera struct {
}
func (p Camera) start() {
    fmt.Println("相机启动")
}
func (p Camera) stop() {
    fmt.Println("相机关机")
}
func main() {
    var computer = Computer{}
    var phone = Phone{
        Name: "小米",
    }
    var camera = Camera{}
    computer.work(phone)
    computer.work(camera)
}

package main
import "fmt"
type A interface{} //空接口  表示没有任何约束  任意的类型都可以实现空接口
func main() {
    var a A
    var str = "你好golang"
    a = str                          //让字符串实现A这个接口
    fmt.Printf("值:%v 类型:%T\n", a, a) //值:你好golang 类型:string
    var num = 20
    a = num //表示让int类型实现A这个接口
    fmt.Printf("值:%v 类型:%T\n", a, a)
    var flag = true
    a = flag //表示让bool类型实现A这个接口
    fmt.Printf("值:%v 类型:%T", a, a)
}

package main
import "fmt"
//golang中空接口也可以直接当做类型来使用，可以表示任意类型
//空接口作为函数的参数
func show(a interface{}) {
    fmt.Printf("值:%v 类型:%T\n", a, a)
}
func main() {
    // var a interface{}
    // a = 20
    // fmt.Printf("值:%v 类型:%T\n", a, a)
    // a = "你好golang"
    // fmt.Printf("值:%v 类型:%T\n", a, a)
    // a = true
    // fmt.Printf("值:%v 类型:%T\n", a, a)
    // show(20)
    // show("你好golang")
    // slice := []int{1, 2, 34, 4}
    // show(slice)
    // var m1 = make(map[string]string)
    // m1["username"] = "张三"
    // m1["age"] = "20"
    // fmt.Println(m1)
    // var m1 = make(map[string]interface{})
    // m1["username"] = "张三"
    // m1["age"] = 20
    // m1["married"] = true
    // fmt.Println(m1)
    var s1 = []interface{}{1, 2, "你好", true} //[1 2 你好 true]
    fmt.Println(s1)
}

package main
import "fmt"
//定义一个方法，可以传入任意数据类型，然后根据不同的类型实现不同的功能
func MyPrint1(x interface{}) {
    if _, ok := x.(string); ok {
        fmt.Println("string类型")
    } else if _, ok := x.(int); ok {
        fmt.Println("int类型")
    } else if _, ok := x.(bool); ok {
        fmt.Println("bool类型")
    }
}
//x.(type) 判断一个变量的类型  这个语句只能用在switch语句里面
func MyPrint2(x interface{}) {
    switch x.(type) {
    case int:
        fmt.Println("int类型")
    case string:
        fmt.Println("string类型")
    case bool:
        fmt.Println("bool类型")
    default:
        fmt.Println("传入错误...")
    }
}
//类型断言
func main() {
    // var a interface{}
    // a = "你好golang"
    // v, ok := a.(string)
    // if ok {
    //     fmt.Println("a就是一个string类型,值是：", v)
    // } else {
    //     fmt.Println("断言失败")
    // }
    // MyPrint1("你好golang")
    // MyPrint1(true)
    MyPrint2("你好golang")
    MyPrint2(true)
}

package main
import "fmt"
type Usber interface {
    start()
    stop()
}
//电脑
type Computer struct {
}
func (c Computer) work(usb Usber) {
    //要判断usb的类型
    if _, ok := usb.(Phone); ok { //类型断言
        usb.start()
    } else {
        usb.stop()
    }
}
//手机
type Phone struct {
    Name string
}
func (p Phone) start() {
    fmt.Println(p.Name, "启动")
}
func (p Phone) stop() {
    fmt.Println(p.Name, "关机")
}
//照相机
type Camera struct {
}
func (p Camera) start() {
    fmt.Println("相机启动")
}
func (p Camera) stop() {
    fmt.Println("相机关机")
}
func main() {
    var computer = Computer{}
    var phone = Phone{
        Name: "小米手机",
    }
    var camera = Camera{}
    computer.work(phone)
    computer.work(camera)
}

package main
import "fmt"
/*
结构体值接收者实现接口：
值接收者： 如果结构体中的方法是值接收者，那么实例化后的结构体值类型和结构体指针类型都可以赋值给接口变量
*/
type Usber interface {
    start()
    stop()
}
type Phone struct {
    Name string
}
func (p Phone) start() { //值接收者
    fmt.Println(p.Name, "启动")
}
func (p Phone) stop() {
    fmt.Println(p.Name, "关机")
}
func main() {
    // 结构体值接收者例化后的结构体值类型和结构体指针类型都可以赋值给接口变量
    var p1 = Phone{
        Name: "小米手机",
    }
    var p2 Usber = p1 //表示让Phone实现Usb的接口
    p2.start()
    var p3 = &Phone{
        Name: "苹果手机",
    }
    var p4 Usber = p3 //表示让Phone实现Usb的接口
    p4.start()
}

package main
import "fmt"
/*
结构体指针接收者实现接口：
指针接收者： 如果结构体中的方法是指针接收者，那么实例化后结构体指针类型都可以赋值给接口变量， 结构体值类型没法赋值给接口变量。
*/
type Usber interface {
    start()
    stop()
}
type Phone struct {
    Name string
}
func (p *Phone) start() { //指针接收者
    fmt.Println(p.Name, "启动")
}
func (p *Phone) stop() {
    fmt.Println(p.Name, "关机")
}
func main() {
    /*
       错误写法
           var phone1 = Phone{
               Name: "小米",
           }
           var p1 Usber = phone1 // Phone does not implement Usber (start method has pointer receiver
           p1.start()
    */
    var phone1 = &Phone{
        Name: "小米",
    }
    var p1 Usber = phone1
    p1.start()
}

package main
import "fmt"
//定义一个Animal的接口，Animal中定义两个方法，分别是SetName和GetName。分别让Dog结构体和Cat结构体实现这个方法
type Animaler interface {
    SetName(string)
    GetName() string
}
type Dog struct {
    Name string
}
func (d *Dog) SetName(name string) {
    d.Name = name
}
func (d Dog) GetName() string {
    return d.Name
}
type Cat struct {
    Name string
}
func (c *Cat) SetName(name string) {
    c.Name = name
}
func (c Cat) GetName() string {
    return c.Name
}
func main() {
    //Dog实现Animal的接口
    d := &Dog{
        Name: "小黑",
    }
    var d1 Animaler = d
    fmt.Println(d1.GetName())
    d1.SetName("阿奇")
    fmt.Println(d1.GetName())
    //Cat实现Animal的接口
    c := &Cat{
        Name: "小花",
    }
    var c1 Animaler = c
    fmt.Println(c1.GetName())
}

package main
import "fmt"
//一个结构体实现多个接口
type Animaler1 interface {
    SetName(string)
}
type Animaler2 interface {
    GetName() string
}
type Dog struct {
    Name string
}
func (d *Dog) SetName(name string) {
    d.Name = name
}
func (d Dog) GetName() string {
    return d.Name
}
func main() {
    //Dog实现Animal的接口
    d := &Dog{
        Name: "小黑",
    }
    var d1 Animaler1 = d //表示让Dog实现Animaler1这个接口
    var d2 Animaler2 = d //表示让Dog实现Animaler2这个接口
    d1.SetName("小花狗狗")
    fmt.Println(d2.GetName()) //小花狗狗
}

package main
import "fmt"
//接口嵌套
type Ainterface interface {
    SetName(string)
}
type Binterface interface {
    GetName() string
}
type Animaler interface { //接口的嵌套
    Ainterface
    Binterface
}
type Dog struct {
    Name string
}
func (d *Dog) SetName(name string) {
    d.Name = name
}
func (d Dog) GetName() string {
    return d.Name
}
func main() {
    //Dog实现Animal的接口
    d := &Dog{
        Name: "小黑",
    }
    var d1 Animaler = d //表示让Dog实现Animaler这个接口
    d1.SetName("小花狗狗")
    fmt.Println(d1.GetName()) //小花狗狗
}

package main
import "fmt"
type Address struct {
    Name  string
    Phone int
}
// Golang中空接口和类型断言使用细节
func main() {
    var userinfo = make(map[string]interface{})
    userinfo["username"] = "张三"
    userinfo["age"] = 20
    userinfo["hobby"] = []string{"睡觉", "吃饭"}
    fmt.Println(userinfo["age"])
    fmt.Println(userinfo["hobby"])
    // fmt.Println(userinfo["hobby"][1]) //interface {} does not support indexing
    var address = Address{
        Name:  "李四",
        Phone: 1521242141,
    }
    fmt.Println(address.Name) //李四
    userinfo["address"] = address
    fmt.Println(userinfo["address"]) //{李四 1521242141}
    // var name = userinfo["address"].Name //type interface {} is interface with no methods
    // fmt.Println(name)
    hobby2, _ := userinfo["hobby"].([]string)
    fmt.Println(hobby2[1]) //吃饭
    address2, _ := userinfo["address"].(Address)
    fmt.Println(address2.Name, address2.Phone) //李四 1521242141
}