golang基础之Interface接口的使用

篮球联盟总裁

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

1. type Interface_Name interface { method_a() string method_b() int .... }

复制代码

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

1. package main
   
2. import "fmt"
   
3. 
   
4. type USB interface { //定义一个接口：方法的集合
   
5.   Name() string //Name方法，返回string
   
6.   Connect()   //Connect方法
   
7. }
   
8. 
   
9. type PhoneConnecter struct { //定义一个结构
   
10.   name string //结构包含一个字段
    
11. }
    
12. 
    
13. func (pc PhoneConnecter) Name() string { //为结构定义一个方法，绑定接口
    
14.   return pc.name //该方法命名为接口内的字段
    
15. } //返回结构体字段
    
16. 
    
17. func (pc PhoneConnecter) Connect() { //定义结构体另一个方法，与接口另一个方法绑定
    
18.   fmt.Println("Connect:", pc.name)
    
19. }
    
20. func main() {
    
21.   var a USB              //定义一个变量为USB接口类型
    
22.   a = PhoneConnecter{"PhoneConnecter"} //实例化一个结构体，并赋值给变量（接口）USB
    
23.   a.Connect()             //接口调用其Connect方法，也是结构方法
    
24. }
    
25. 
    
26. /*输出
    
27. Connect: PhoneConnecter
    
28. */

复制代码

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

1. package main
   
2. import "fmt"
   
3. 
   
4. type USB interface { //定义一个接口：方法的集合
   
5.   Name() string //Name方法，返回string
   
6.   Connecter   //嵌入Connecter接口，可以使用Connecter方法
   
7. }
   
8. 
   
9. type Connecter interface { //定义另一个接口 Connecter
   
10.   Connect() //包含一个接口方法：Connect
    
11. }
    
12. type PhoneConnecter struct { //定义一个结构
    
13.   name string //结构包含一个字段
    
14. }
    
15. 
    
16. func (pc PhoneConnecter) Name() string { //为结构定义一个方法，绑定接口
    
17.   return pc.name //该方法命名为接口内的字段
    
18. } //返回结构体字段
    
19. 
    
20. func (pc PhoneConnecter) Connect() { //定义结构体另一个方法，与接口另一个方法绑定
    
21.   fmt.Println("Connect:", pc.name)
    
22. }
    
23. func main() {
    
24.   var a USB              //定义一个变量为USB接口类型
    
25.   a = PhoneConnecter{"PhoneConnecter"} //实例化一个结构体，并赋值给变量（接口）USB
    
26.   a.Connect()
    
27.   Disconnect(a) //接口调用其Connect方法，也是结构方法
    
28. }

复制代码

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

1. package main
   
2. import "fmt"
   
3. 
   
4. type USB interface { //定义一个接口：方法的集合
   
5.   Name() string //Name方法，返回string
   
6.   Connecter   //嵌入Connecter接口，可以使用Connecter方法
   
7. }
   
8. 
   
9. type Connecter interface { //定义另一个接口 Connecter
   
10.   Connect() //包含一个接口方法：Connect
    
11. }
    
12. type PhoneConnecter struct { //定义一个结构
    
13.   name string //结构包含一个字段
    
14. }
    
15. 
    
16. func (pc PhoneConnecter) Name() string { //为结构定义一个方法，绑定接口
    
17.   return pc.name //该方法命名为接口内的字段
    
18. } //返回结构体字段
    
19. 
    
20. func (pc PhoneConnecter) Connect() { //定义结构体另一个方法，与接口另一个方法绑定
    
21.   fmt.Println("Connected:", pc.name)
    
22. }
    
23. func main() {
    
24.   var a USB           //定义一个变量为USB接口类型
    
25.   a = PhoneConnecter{"htc M10"} //实例化一个结构体，并赋值给变量（接口）USB
    
26.   a.Connect()
    
27.   Disconnect(a) //接口调用其Connect方法，也是结构方法
    
28. }
    
29. 
    
30. func Disconnect(usb USB) {
    
31.   if pc, ok := usb.(PhoneConnecter); ok { //传入结构体，判断赋值是否成功
    
32.     fmt.Println("Disconnected:", pc.name)
    
33.     return
    
34.   }
    
35.   fmt.Println("UNknown device.")
    
36. }
    
37. 
    
38. /*输出
    
39. Connect: htc M10
    
40. Disconnect:htc M10
    
41. */

复制代码

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

1. package main
   
2. import "fmt"
   
3. 
   
4. type USB interface { //定义一个接口：方法的集合
   
5.   Name() string //Name方法，返回string
   
6.   Connecter   //嵌入Connecter接口，可以使用Connecter方法
   
7. }
   
8. 
   
9. type Connecter interface { //定义另一个接口 Connecter
   
10.   Connect() //包含一个接口方法：Connect
    
11. }
    
12. type PhoneConnecter struct { //定义一个结构
    
13.   name string //结构包含一个字段
    
14. }
    
15. 
    
16. func (pc PhoneConnecter) Name() string { //为结构定义一个方法，绑定接口
    
17.   return pc.name //该方法命名为接口内的字段
    
18. } //返回结构体字段
    
19. 
    
20. func (pc PhoneConnecter) Connect() { //定义结构体另一个方法，与接口另一个方法绑定
    
21.   fmt.Println("Connected:", pc.name)
    
22. }
    
23. func main() {
    
24.   var a USB           //定义一个变量为USB接口类型
    
25.   a = PhoneConnecter{"htc M10"} //实例化一个结构体，并赋值给变量（接口）USB
    
26.   a.Connect()
    
27.   Disconnect(a) //接口调用其Connect方法，也是结构方法
    
28. }
    
29. 
    
30. # func Disconnect(usb interface{}) { //集成空接口，也可以实现
    
31. #  if pc, ok := usb.(PhoneConnecter); ok { //传入结构体，判断赋值是否成功
    
32. #    fmt.Println("Disconnected:", pc.name)
    
33. #    return
    
34. #  }
    
35. #  fmt.Println("UNknown device.")
    
36. #  }
    
37. 
    
38. //通过switch判断接口类型：type...switch用法
    
39. func Disconnect(usb interface{}) { //集成空接口，也可以实现
    
40. switch v := usb.(type) {
    
41. case PhoneConnecter:
    
42.   fmt.Println("Disconnected:", v.name)
    
43. default:
    
44.   fmt.Println("UNknown device.")
    
45. }
    
46. }
    
47. 
    
48. /*输出
    
49. Connect: htc M10
    
50. Disconnect:htc M10
    
51. */

复制代码

接口间的转换： 只有子类接口可以转换为父类接口，因为父类接口包含了子类接口，子类接口可以调用父类接口一部分接口方法
将对象赋值给接口是，会发生拷贝，而接口内部存储的是只想这个复制品的指针，也就意味着接口无法修改状态，也无法获取指针。

1. ...
   
2. func main() {
   
3. pc := PhoneConnecter{"ipad book pro"} //实例化一个结构
   
4. var a Connecter            //定义a为接口变量
   
5. a = Connecter(pc)           //接口强制转换
   
6. a.Connect()
   
7. 
   
8. pc.name = "Iphone 7"
   
9. a.Connect()
   
10. ...
    
11. 
    
12. /*输出
    
13. pc.name= "ipad book pro"  Connected: ipad book pro
    
14. pc.name = "Iphone 7"    Connected: ipad book pro
    
15. */
    
16. }

复制代码

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

1. package main
   
2. import "fmt"
   
3. 
   
4. func main() {
   
5.   var a interface{}
   
6.   fmt.Println(a == nil)
   
7. 
   
8.   var p *int = nil
   
9.   a = p
   
10.   fmt.Println(a == nil)
    
11. }
    
12. 
    
13. /*输出
    
14. true
    
15. false
    
16. */

复制代码

  

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

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

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

最爱楚苏楼等

谢谢分享~~~~~

澹台秀筠

路过，支持一下

降法讲顾

顶顶更健康！！！