基本介绍

如果一个类型实现了某个接口，所有使用这个接口的地方，都可以支持这种类型的值。
interface 类型可以定义一组方法，并且 interface 不能包含任何变量。
接口是用来定义行为的类型。这些被定义的行为不由接口直接实现，而是通过方法由用户定义的类型实现。
（行为就是方法，由用户定义的类型实现）
好处： 多态 ，高内聚、低耦合
高内聚：可以把代码全部写到函数里面去。
低耦合： 各司其职，各自负责自己的，(处理自己的错误，不要抛给别人)。

语法

  1. type 接口名 interface {
  2.     // 不能在这里定义变量
  3.     method1(参数列表) (返回值列表)
  4.     method2(参数列表) (返回值列表)
  5. }
  7. // 接口定义的行为由用户定义的类型实现方法(实现所有的行为)
  8. func (t 自定义类型) method1(参数列表) (返回值列表) {
  9.     // 方法时实现
  10. }
  11. func (t 自定义类型) method2(参数列表) (返回值列表) {
  12.     // 方法时实现
  13. }
  15. // method1 method2 是签名，必须跟接口里定义的行为保持一致

USB接口例子

  1. package main
  3. import "fmt"
  5. // 定义 Usb 接口， 有两个方法(行为)
  6. type Usb interface {
  7.     start()
  8.     stop()
  9. }
  11. // 定义 Phone 结构体， 并实现 start, stop 方法
  12. type Phone struct {
  13.     Name string
  14. }
  16. // 值接收者
  17. // Phone 类型实现了 Usb 接口 (就是实现了 Usb 接口的所有方法)
  18. func (phone Phone) start() {
  19.     fmt.Printf("%v开始--- \n", phone.Name)
  20. }
  21. func (phone Phone) stop() {
  22.     fmt.Printf("%v停止--- \n", phone.Name)
  23. }
  25. // 定义 Camera 结构体， 并实现 start, stop 方法
  26. type Camera struct {
  27.     Name string
  28. }
  30. // 指针接收者
  31. // Camera 指针类型实现了 Usb 接口 (就是实现了 Usb 接口的所有方法)
  32. func (camera *Camera) start() {
  33.     fmt.Printf("%v开始--- \n", camera.Name)
  34. }
  35. func (camera *Camera) stop() {
  36.     fmt.Printf("%v停止--- \n", camera.Name)
  37. }
  39. // 定义 Computer 结构体, 并实现 Working 方法
  40. type Computer struct {
  41. }
  43. // 编写 Working 方法，接收一个 Usb 接口类型的变量，
  44. // 只要一个类型实现了某个接口，那么所有使用这个接口的地方，都支持这种类型的值
  45. //  (比如： 实参 phone, camera, 都是 Usb 类型来接收， 这就是多态)
  46. func (computer *Computer) Working(usb Usb) {
  47.     usb.start()
  48.     usb.stop()
  49. }
  51. func main() {
  52.     computer := Computer{}
  53.     phone := Phone{"手机"}
  54.     camera := Camera{"相机"}
  56.     computer.Working(phone)   // 值接收者
  57.     computer.Working(&camera) // 指针接收者(因为是 *Camera 类型实现的 Usb 接口)
  58.     /*
  59.         手机开始---
  60.         手机停止---
  61.         相机开始---
  62.         相机停止---
  63.     */
  64. }

接口实现

接口是用来定义行为的类型。这些被定义的行为不由接口直接实现，而是通过方法由用户定义的类型实现。如果用户定义的类型实现了某个接口类型声明的一组方法，那么这个用户定义的类型的值就可以赋给这个接口类型的值。这个赋值会把用户定义的类型的值存入接口类型的值。
对接口值方法的调用会执行接口里存储的用户定义的类型的值对应的方法。因为任何用户定义的类型都可以实现任何接口，所以对接口值方法的调用自然就是一种多态，在这个关系里，用户定义的类型通常叫作实体类型，原因是如果离开内部存储的用户定义的类型的值的实现，接口值并没有具体的行为。

Go官方例子

  1. package main
  3. import "fmt"
  5. // notifier 是一个定义了通知类行为的接口
  6. type notifier interface {
  7.     notify()
  8. }
  10. // user 在程序里定义一个用户类型
  11. type user struct {
  12.     name  string
  13.     email string
  14. }
  16. // notify 是使用指针接收者实现的 notifier 接口
  17. func (u *user) notify() {
  18.     fmt.Printf("Sending user email to %s<%s> \n",
  19.         u.name,
  20.         u.email)
  21. }
  23. func main() {
  24.     // 创建一个 user 类型的值，并发送通知
  25.     u := user{"Bill", "bill@email.com"}
  26.     // sendNotification(u) // 传入值， 值并没有实现 notifier 接口
  27.     /*
  28.         报错：
  29.         cannot use u (type user) as type notifier in argument to sendNotification:
  30.         user does not implement notifier (notify method has pointer receiver)
  31.     */
  32.     sendNotification(&u) // 传入地址
  33.     // Sending user email to Bill<bill@email.com>
  34. }
  36. // sendNotification 接收一个实现了 notifier 接口的值，并发送通知
  37. func sendNotification(n notifier) {
  38.     n.notify()
  39. }

方法集

用户定义的类型的值或者指针要满足接口的实现，需要遵守一些规则。
规范里描述的方法集：

  1. Values                           Methods Receivers
  2. ---------------------------------------------------------
  3. T                                (t T)
  4. *T                               (t T) and (t *T)

从接收者类型角度看方法集：

  1. Methods Receivers                Values
  2. ---------------------------------------------------------
  3. (t T)                            T and *T
  4. (t *T)                           *T

多态

多态是指代码可以根据类型的具体实现采取不同行为的能力

Go方法例子

  1. // 多态例子
  2. package main
  4. import "fmt"
  6. // notifier 是一个定义了通知类行为的接口
  7. type notifier interface {
  8.     notify()
  9. }
  11. // user 在程序里定义一个用户类型
  12. type user struct {
  13.     name  string
  14.     email string
  15. }
  17. // notify 是使用指针接收者实现的notifier接口
  18. func (u *user) notify() {
  19.     fmt.Printf("Sending user email to %s<%s> \n",
  20.         u.name,
  21.         u.email)
  22. }
  24. // -------------以下代码是相对于接口demo新增的，展示多态--------------
  25. // admin 在程序里定义一个用户类型
  26. type admin struct {
  27.     name  string
  28.     email string
  29. }
  31. // notify 是使用指针接收者实现的notifier接口
  32. func (u *admin) notify() {
  33.     fmt.Printf("Sending admin email to %s<%s> \n",
  34.         u.name,
  35.         u.email)
  36. }
  38. func main() {
  39.     // 创建一个 user 类型的值，并传递给 sendNotification
  40.     bill := user{"Bill", "bill@email.com"}
  41.     sendNotification(&bill)
  43.     // 创建一个 admin 类型的值，并传递给 sendNotification
  44.     lisa := admin{"Lisa", "lisa@email.com"}
  45.     sendNotification(&lisa)
  46. }
  48. // sendNotification 接收一个实现了 notifier 接口的值，并发送通知
  49. // 多态函数
  50. func sendNotification(n notifier) {
  51.     n.notify()
  52. }

代码解读

声明了 user 和 admin 两个结构，都实现了 notifier 接口（两个实体类型实现了 notifier 接口）
声明了多态函数 sendNotification， 这个函数接收一个实现了 notifier 接口的值作为参数。既然任意一个实体类型都能实现该接口，那么这个函数可以针对任意实体类型的值来执行 notifier 方法，因此这个函数就能提供多态的行为。可以同时执行user和admin实现的行为。

  1. func main() {
  2.     // 创建一个 user 类型的值，并传递给 sendNotification
  3.     bill := user{"Bill", "bill@email.com"}
  4.     sendNotification(&bill)
  6.     // 创建一个 admin 类型的值，并传递给 sendNotification
  7.     lisa := admin{"Lisa", "lisa@email.com"}
  8.     sendNotification(&lisa)
  9. }

接口使用细节

  1. 接口本身不能创建实例，但是可以指向一个实现了该接口的自定义类型的变量（实例）
  2. 接口中的所有方法都没有方法体（即没有直接实现方法）
  3. 在Golang中，一个自定义类型需要将某个接口的所有方法都实现，我们称这个自定义类型实现了该接口
  4. 只要是自定义数据类型，就可以实现接口，不仅仅是结构体类型。
  5. 一个自定义类型可以实现多个接口
  6. 一个接口（比如A接口）可以继承多个别的接口（比如B、C接口），这时如果要实现A接口，也必须将B、C接口的方法全部实现。
  7. interface类型默认是一个指针（引用类型），如果没有初始化interface，则会输出 nil
  8. 空接口 interface{} 没有任何方法（行为），所以，所有类型都实现了空接口
    1. var blank02 interface{} //

image.png

代码案例一

  1. package main
  3. import "fmt"
  5. type AInterface interface {
  6.     Say()
  7. }
  9. type Student struct {
  10.     Name string
  11. }
  13. // 如果 Student 没有实现 Say() 方法，则调用时报错
  14. // Student does not implement AInterface (missing Say method)
  15. func (stu Student) Say() {
  16.     fmt.Printf("name= %v \n", stu.Name)
  17. }
  19. type cusInt int
  21. // 数值类型实现接口
  22. func (i cusInt) Say() {
  23.     fmt.Println("我是数值类型")
  24. }
  26. func main() {
  27.     var a AInterface
  28.     fmt.Printf("a类型： %T, 值： %v \n", a, a)
  29.     // 直接调用接口的方法 报错
  30.     // 需要通过自定义类型实现方法
  31.     // a.Say() // panic: runtime error: invalid memory address or nil pointer dereference
  33.     // Student 类型实现了 AInterface 接口定义的所有方法(即实现了接口)
  34.     // 所以， Student 的实例 stu 可以赋值给 AInterface 类型
  35.     var stu Student = Student{"tom"}
  36.     var a1 AInterface = stu
  37.     a1.Say() // name= tom
  39.     // 数值类型调用接口
  40.     var i cusInt
  41.     callSay(i)
  42. }
  44. func callSay(a AInterface) {
  45.     a.Say()
  46. }

代码案例二

  1. // 接口继承，以及实现，空接口
  2. package main
  4. import "fmt"
  6. type BInterface interface {
  7.     test01()
  8. }
  9. type CInterface interface {
  10.     test02()
  11. }
  13. // 要实现 AInterface 接口，必要同时实现 BInterface、CInterface接口
  14. type AInterface interface {
  15.     BInterface
  16.     CInterface
  17.     test03()
  18. }
  20. type Student struct {
  21. }
  23. func (stu Student) test01() {}
  24. func (stu Student) test02() {}
  25. func (stu Student) test03() {}
  27. type blankInterface interface{}
  29. func main() {
  30.     var stu Student
  31.     var a AInterface = stu
  32.     a.test01()
  34.     // 空接口
  35.     var b blankInterface
  36.     var blank blankInterface = 10
  37.     fmt.Printf("b类型： %T, 值： %v \n", b, b)             // b类型： <nil>, 值： <nil>
  38.     fmt.Printf("blank类型： %T, 值： %v \n", blank, blank) // blank类型： int, 值： 10
  40.     // 直接定义空接口
  41.     var blank02 interface{}
  42.     fmt.Printf("blank02类型： %T, 值： %v \n", blank02, blank02) // blank02类型： <nil>, 值： <nil> 
  43. }

嵌入类型（继承与接口）

type embedding

  1. 通过嵌入类型，与内部类型相关的标识符会提升到外部类型上。（类似于JavaScript中的原型链）
  2. 这个外部类型就组合了内部类型包含的所有属性，并且可以添加新的字段和方。
  3. 外部类型也可以通过声明于内部类型标识符同名的标识符来覆盖内部标识符的字段或者方法，这就是扩展或者修改已有类型的方法 ```go // 这个示例程序展示如何将一个类型嵌入另一个类型 // 内部类型和外部类型之间的关系 package main

import “fmt”

// user 在程序里定义一个用户类型 type user struct { name string email string }

// notify 实现了一个可以通过user类型值得指针调用得方法 func (u *user) notify() { fmt.Printf(“Sending user email to %s<%s> \n”, u.name, u.email) }

// admin 代表一个拥有权限得管理员用户 // 要嵌入一个类型，只需要声明这个类型的名字就可以了 // user 是外部类型 admin 的内部类型 type admin struct { user // 嵌入类型 level string }

func main() { // 创建一个 admin 用户 // 内部类型的初始化采用结构字面量的方式完成 ad := admin{ user: user{ name: “join”, email: “join@yahoo.com”, }, level: “super”, } // 直接访问内部类型的方法 ad.user.notify() // 内部类型的方法也被提升到外部类型 ad.notify()

  1. /*
  2.     输出
  3.     Sending user email to join<join@yahoo.com>
  4.     Sending user email to join<join@yahoo.com>
  5. */

}

  1. <a name="OHonH"></a>
  2. ## 嵌入类型接口实现
  3. ```go
  4. // 演示如何将嵌入类型应用于接口
  5. package main
  7. import "fmt"
  9. // notifier 是一个定义了通知类行为的接口
  10. type notifier interface {
  11.     notify()
  12. }
  14. // user 在程序里定义一个用户类型
  15. type user struct {
  16.     name  string
  17.     email string
  18. }
  20. // notify 是使用指针接收者实现的notifier接口
  21. func (u *user) notify() {
  22.     fmt.Printf("Sending user email to %s<%s> \n",
  23.         u.name,
  24.         u.email)
  25. }
  27. // admin 代表一个拥有权限得管理员用户
  28. // 要嵌入一个类型，只需要声明这个类型的名字就可以了
  29. // user 是外部类型 admin 的内部类型
  30. type admin struct {
  31.     user  // 嵌入类型
  32.     level string
  33. }
  35. func main() {
  36.     // 创建一个 admin 用户
  37.     // 内部类型的初始化采用结构字面量的方式完成
  38.     ad := admin{
  39.         user: user{
  40.             name:  "join",
  41.             email: "join@yahoo.com",
  42.         },
  43.         level: "super",
  44.     }
  46.     // 给 admin 用户发送一个通知
  47.     // 用于实现接口的内部类型的方法，被提升到外部类型
  48.     sendNotification(&ad)
  49. }
  51. // sendNotification 接收一个实现了 notifier 接口的值，并发送通知
  52. func sendNotification(n notifier) {
  53.     n.notify()
  54. }
  57. // Sending user email to join<join@yahoo.com>

外部类型与内部类型实现同一个接口

此时，实现接口的内部类型的方法，不会被提升到外部类型。

  1. // 这个示例程序展示当内部类型和外部类型要实现同一个接口的做法
  2. package main
  4. import "fmt"
  6. // notifier 是一个定义了通知类行为的接口
  7. type notifier interface {
  8.     notify()
  9. }
  11. // user 在程序里定义一个用户类型
  12. type user struct {
  13.     name  string
  14.     email string
  15. }
  17. // 通过 user 类型的指针调用的方法
  18. func (u *user) notify() {
  19.     fmt.Printf("Sending user email to %s<%s> \n",
  20.         u.name,
  21.         u.email)
  22. }
  24. // admin 代表一个拥有权限得管理员用户
  25. type admin struct {
  26.     user  // 嵌入类型
  27.     level string
  28. }
  30. // 通过 admin 类型的指针调用的方法
  31. func (u *admin) notify() {
  32.     fmt.Printf("Sending admin email to %s<%s> \n",
  33.         u.name,
  34.         u.email)
  35. }
  37. func main() {
  38.     // 创建一个 admin 用户
  39.     ad := admin{
  40.         user: user{
  41.             name:  "john",
  42.             email: "john@yahoo.com",
  43.         },
  44.         level: "super",
  45.     }
  46.     // 给 admin 用户发送通知
  47.     // 接口嵌入的内部类型实现并没有提升到外部类型
  48.     sendNotification(&ad) // Sending admin email to john<john@yahoo.com>
  50.     // 我们可以直接访问内部类型的方法
  51.     ad.user.notify() // Sending user email to john<john@yahoo.com>
  53.     // 内部类型的方法没有被提升
  54.     ad.notify() // Sending admin email to john<john@yahoo.com>
  55. }
  57. // sendNotification 接收一个实现了 notifier 接口的值，并发送通知
  58. func sendNotification(n notifier) {
  59.     n.notify()
  60. }