interface

package main

/*
接口interface

接口是一个或多个方法签名的集合
只要某个类型拥有该接口的所有方法签名，即算实现该接口，无需显示
声明实现了哪个接口，这称为 Structural Typing
接口只有方法声明，没有实现，没有数据字段
接口可以匿名嵌入其它接口，或嵌入到结构中
将对象赋值给接口时，会发生拷贝，而接口内部存储的是指向这个
复制品的指针，既无法修改复制品的状态，也无法获取指针
只有当接口存储的类型和对象都为nil时，接口才等于nil
接口调用不会做receiver的自动转换
接口同样支持匿名字段方法
接口也可实现类似OOP中的多态
空接口可以作为任何类型数据的容器

*/

import (
    "fmt"
)

type empty interface{} //任何结构都实现了空接口，

type ReadWrite interface {
    readwrite()
}

type USB interface {
    Name() string //name方法返回usb的名称
    Connect()     //连接的方法
    ReadWrite     //接口的嵌入
}

type PhoneConect struct {
    name string
}

//PhoneConect实现USB接口
//go语言没有显示说明实现了哪个接口，只要实现了接口中的方法就表示实现了接口
func (pc PhoneConect) Name() string { //为接口添加方法,就是实现了接口USB
    return pc.name
}

func (pc PhoneConect) Connect() { //为接口添加方法，就是实现了接口USB
    fmt.Println("connect..", pc.name)
}

func (pc PhoneConect) readwrite() { //为接口添加方法，就是实现了接口USB，（每个方法都要实现）
    fmt.Println("readwrite...")
}

func main() {
    var a USB                             //a是一个USB接口类型
    a = PhoneConect{name: "PhoneConnect"} //PhoneConect实现了USB接口中的方法，就可以赋值给USB，子类可以给父类赋值，
    //a.name = "PhoneConnect"不能这写
    a.Connect()
    Disconnect(a) //Disconnect..

    a1 := PhoneConect{name: "PhoneConnect1"}
    Disconnect(a1) //Disconnect..
}

func Disconnect(usb USB) {
    if pcc, ok := usb.(PhoneConect); ok { //判断是不是PhoneConect，是的话ok=true,
        fmt.Println("pcc=", pcc)      //pcc= {PhoneConnect}
        fmt.Println("ok", ok)         //ok true
        fmt.Println("是usb", pcc.name) //是usb PhoneConnect
    }
    fmt.Println("Disconnect..")
}

func Disconnect1(usb interface{}) { //参数是空接口，表示可以接收任何类型，
    switch v := usb.(type) { //类型判断
    case PhoneConect:
        fmt.Println("disconnect..", v.name)
    default:
        fmt.Println("unknow")
    }
}

package main

import (
    "fmt"
)

type Connecter interface {
    Connect()
}

type USB interface {
    Name() string
    Connecter
}

type PhoneConect struct {
    name string
}

//PhoneConect实现USM接口
func (pc PhoneConect) Name() string {
    return pc.name
}

func (pc PhoneConect) Connect() {
    fmt.Println("connect..", pc.name)
}

func main() {
    a1 := PhoneConect{name: "PhoneConnect1"}
    var a2 USB
    var a3 Connecter
    a2 = USB(a1)       //子类强制转换为父类
    a3 = Connecter(a1) //子类强制转换为父类，只能调用父类的方法，不恩调用子类的方法

    a2.Connect()           //connect.. PhoneConnect1
    fmt.Println(a2.Name()) //PhoneConnect1
    a3.Connect()           //connect.. PhoneConnect1
    //a3.Name()没有这个方法了，只能调用父类的方法，不恩调用子类的方法（java也是，需要强制转化为子类对象）
}

package main

import (
    "fmt"
)

type Connecter interface {
    Connect()
}

type USB interface {
    Name() string
    Connecter
}

type PhoneConect struct {
    name string
}

//PhoneConect实现USM接口
func (pc PhoneConect) Name() string {
    return pc.name
}

func (pc PhoneConect) Connect() {
    fmt.Println("connect..", pc.name)
}

func main1() {
    a1 := PhoneConect{name: "PhoneConnect1"} //子类
    var a3 Connecter                         //父类
    a3 = Connecter(a1)                       //子类强制转换成父类

    a3.Connect()              //父类对象也只能调用父类有的方法,connect.. PhoneConnect1
    a1.name = "PhoneConnect2" //子类的属性改了
    a3.Connect()              //connect.. PhoneConnect1，父类并没有改，说明子类给接口赋值拿到的是一个拷贝
    //因此，将对象赋值给接口时，会发生拷贝，而接口内部存储的是指向这个
    //复制品的指针，既无法修改复制品的状态，也无法获取指针

}

func main() {
    var a1 interface{}     //空接口是一个类型,不能写成var a1 := interface{}
    fmt.Println(a1 == nil) //true

    var p *int = nil //p是指向int型的指针
    a1 = p
    fmt.Println(a1 == nil) //false
}