golang基础之Interface接口的使用

接口是一个或多个方法签名名的集合，定义方式如下

type interface_name interface { method_a() string method_b() int .... } 

只要某个类型拥有该接口的所有方法签名，就算实现该接口，无需显示声明实现了那个接口，这称为structural typing

package main
import "fmt"

type usb interface { //定义一个接口：方法的集合
  name() string //name方法，返回string
  connect()   //connect方法
}

type phoneconnecter struct { //定义一个结构
  name string //结构包含一个字段
}

func (pc phoneconnecter) name() string { //为结构定义一个方法，绑定接口
  return pc.name //该方法命名为接口内的字段
} //返回结构体字段

func (pc phoneconnecter) connect() { //定义结构体另一个方法，与接口另一个方法绑定
  fmt.println("connect:", pc.name)
}
func main() {
  var a usb              //定义一个变量为usb接口类型
  a = phoneconnecter{"phoneconnecter"} //实例化一个结构体，并赋值给变量（接口）usb
  a.connect()             //接口调用其connect方法，也是结构方法
}

/*输出
connect: phoneconnecter
*/

接口可以作为匿名嵌入其它接口，或嵌入到结构中

package main
import "fmt"

type usb interface { //定义一个接口：方法的集合
  name() string //name方法，返回string
  connecter   //嵌入connecter接口，可以使用connecter方法
}

type connecter interface { //定义另一个接口 connecter
  connect() //包含一个接口方法：connect
}
type phoneconnecter struct { //定义一个结构
  name string //结构包含一个字段
}

func (pc phoneconnecter) name() string { //为结构定义一个方法，绑定接口
  return pc.name //该方法命名为接口内的字段
} //返回结构体字段

func (pc phoneconnecter) connect() { //定义结构体另一个方法，与接口另一个方法绑定
  fmt.println("connect:", pc.name)
}
func main() {
  var a usb              //定义一个变量为usb接口类型
  a = phoneconnecter{"phoneconnecter"} //实例化一个结构体，并赋值给变量（接口）usb
  a.connect()
  disconnect(a) //接口调用其connect方法，也是结构方法
}

接口只是方法声明，没有实现调用，没有字段，只能通过绑定的类型方法访问

package main
import "fmt"

type usb interface { //定义一个接口：方法的集合
  name() string //name方法，返回string
  connecter   //嵌入connecter接口，可以使用connecter方法
}

type connecter interface { //定义另一个接口 connecter
  connect() //包含一个接口方法：connect
}
type phoneconnecter struct { //定义一个结构
  name string //结构包含一个字段
}

func (pc phoneconnecter) name() string { //为结构定义一个方法，绑定接口
  return pc.name //该方法命名为接口内的字段
} //返回结构体字段

func (pc phoneconnecter) connect() { //定义结构体另一个方法，与接口另一个方法绑定
  fmt.println("connected:", pc.name)
}
func main() {
  var a usb           //定义一个变量为usb接口类型
  a = phoneconnecter{"htc m10"} //实例化一个结构体，并赋值给变量（接口）usb
  a.connect()
  disconnect(a) //接口调用其connect方法，也是结构方法
}

func disconnect(usb usb) {
  if pc, ok := usb.(phoneconnecter); ok { //传入结构体，判断赋值是否成功
    fmt.println("disconnected:", pc.name)
    return
  }
  fmt.println("unknown device.")
}

/*输出
connect: htc m10
disconnect:htc m10
*/

go没有像其他语言继承，如python中的object表示元类，所有的类都继承自object类，go通过接口也类似实现了此定义，因为只要某个类型实现了某个接口的方法，我们就说此类实现了这个接口。 因为 type empty interface{} ---空接口没有任何方法，所以可以理解为所有的接口都实现了空接口的方法（继承）。

package main
import "fmt"

type usb interface { //定义一个接口：方法的集合
  name() string //name方法，返回string
  connecter   //嵌入connecter接口，可以使用connecter方法
}

type connecter interface { //定义另一个接口 connecter
  connect() //包含一个接口方法：connect
}
type phoneconnecter struct { //定义一个结构
  name string //结构包含一个字段
}

func (pc phoneconnecter) name() string { //为结构定义一个方法，绑定接口
  return pc.name //该方法命名为接口内的字段
} //返回结构体字段

func (pc phoneconnecter) connect() { //定义结构体另一个方法，与接口另一个方法绑定
  fmt.println("connected:", pc.name)
}
func main() {
  var a usb           //定义一个变量为usb接口类型
  a = phoneconnecter{"htc m10"} //实例化一个结构体，并赋值给变量（接口）usb
  a.connect()
  disconnect(a) //接口调用其connect方法，也是结构方法
}

# func disconnect(usb interface{}) { //集成空接口，也可以实现
#  if pc, ok := usb.(phoneconnecter); ok { //传入结构体，判断赋值是否成功
#    fmt.println("disconnected:", pc.name)
#    return
#  }
#  fmt.println("unknown device.")
#  }

//通过switch判断接口类型：type...switch用法
func disconnect(usb interface{}) { //集成空接口，也可以实现
switch v := usb.(type) {
case phoneconnecter:
  fmt.println("disconnected:", v.name)
default:
  fmt.println("unknown device.")
}
}

/*输出
connect: htc m10
disconnect:htc m10
*/

接口间的转换： 只有子类接口可以转换为父类接口，因为父类接口包含了子类接口，子类接口可以调用父类接口一部分接口方法

将对象赋值给接口是，会发生拷贝，而接口内部存储的是只想这个复制品的指针，也就意味着接口无法修改状态，也无法获取指针。

...
func main() {
pc := phoneconnecter{"ipad book pro"} //实例化一个结构
var a connecter            //定义a为接口变量
a = connecter(pc)           //接口强制转换
a.connect()

pc.name = "iphone 7"
a.connect()
...

/*输出
pc.name= "ipad book pro"  connected: ipad book pro
pc.name = "iphone 7"    connected: ipad book pro
*/
}

只有当 接口存储的类型和对象都为nil时，接口才等于nil

package main
import "fmt"

func main() {
  var a interface{}
  fmt.println(a == nil)

  var p *int = nil
  a = p
  fmt.println(a == nil)
}

/*输出
true
false
*/

1. 接口调用不会做receiver的自动转换
2. 接口同样支持匿名字段的方法
3. 接口也可以实现类似oop(面向对象编程)中的多态
4. 空接口可以作为任何类型数据的容器

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。