隐式接口

Java中接口

Java 的接口不仅可以定义方法签名，还可以定义变量，这些定义的变量可以直接在实现接口的类中使用，这里简单介绍一下 Java 中的接口：

  2. // 定义 Human 接口有 run 跟 say 两个方法
  3. interface HumanInterface {
  4.     public void run();
  5.     public void say();
  6. }
  7. // 实现 Human 接口 必须实现所有方法 run 与 say
  8. class Human implements HumanInterface {
  9.     public int age;
  10.     public String name;
  11.     public void run() {
  12.         System.out.println("I can run");
  13.     }
  14.     public void say() {
  15.         System.out.println("I can say");
  16.     }
  17. }
  18. // 歌手
  19. class Singer extends Human {
  20.     public String collection; // 专辑
  21.     public void sing() {
  22.         System.out.println("I can sing");
  23.     }
  24. }
  26. // 学生
  27. class Student extends Human {
  28.     public String lesson;
  29.     public Student(String lesson){
  30.         this.lesson = lesson;
  31.     }
  32.     public void learn() {
  33.         System.out.println("I need learn " + this.lesson);
  34.     }
  35. }
  37. class Test {
  38.     public static void main(String[] args) {
  39.         Singer singer = new Singer();
  40.         // 父类Human实现了接口的主法
  41.         singer.run();
  42.         singer.say();
  44.         // Singer类自己的方法
  45.         singer.sing();
  47.         System.out.println("\n");
  49.         Student student = new Student("Golang");
  51.         // 父类Human实现了接口的主法
  52.         student.run();
  53.         student.say();
  55.         // Student类自己的方法
  56.         student.learn();
  58.         /**
  59.          * I can run
  60.          * I can say
  61.          * I can sing
  62.          *
  63.          *
  64.          * I can run
  65.          * I can say
  66.          * I need learn Golang
  67.          */
  68.     }
  69. }

Java 中 class 通过 implement 显式地声明实现 interface 的所有方法。

但是在 Go 语言中实现接口就不需要使用类似的方式，用go实现

  1. package main
  3. import "fmt"
  5. // interface
  6. type HumanInterface interface {
  7.     Say()
  8.     Run()
  9. }
  11. type Human struct {
  12.     name string
  13.     age int
  14. }
  16. // 实现 Human 接口 方法 run 与 say
  17. func (h Human) Say() {
  18.     fmt.Printf("I can say, I am %s, %d years old\n", h.name, h.age)
  19. }
  21. func (h Human) Run() {
  22.     fmt.Printf("%s is running\n", h.name)
  23. }
  25. type Singer struct {
  26.     Human
  27.     collecton string
  28. }
  30. func (s Singer) Sing() {
  31.     fmt.Printf("%s can sing %s\n", s.name, s.collecton)
  32. }
  34. type Student struct{
  35.     Human
  36.     lesson string
  37. }
  39. func (s Student) Learn() {
  40.     fmt.Printf("%s nee learn %s\n", s.name, s.lesson)
  41. }
  44. func main() {
  45.     hailun := Singer{Human{"海伦", 18}, "《桥边姑娘》"}
  46.     tom := Student{Human{"Tom", 18}, "《Go从入门到放弃》"}
  47.     human := Human{"我是人类", 26}
  49.     var men HumanInterface
  51.     fmt.Println("\n------hailun-----")
  52.     // men 存 hailun
  53.     men = hailun
  54.     men.Say()
  55.     men.Run()
  56.     // men.Sing() 不能调用 Sing() Men 没有 Sing()
  59.     fmt.Println("\n------tom-----")
  60.     // men 存 tom
  61.     men = tom
  62.     men.Say()
  63.     men.Run()
  64.     // men.Learn() 同理
  67.     fmt.Println("\n------human-----")
  68.     // men 存 human
  69.     men = human
  70.     men.Say()
  71.     men.Run()
  74.     fmt.Println("\n------x-----")
  75.     x := make([]HumanInterface, 3)
  76.     // 这三个都是不同类型的元素，但是他们实现了 interface 同一个接口
  77.     x[0], x[1], x[2] = hailun, tom, human
  79.     for _, value := range x{
  80.         value.Say()
  81.         value.Run()
  82.     }
  83. }
  85. /*
  86. ------hailun-----
  87. I can say, I am 海伦, 18 years old
  88. 海伦 is running
  90. ------tom-----
  91. I can say, I am Tom, 18 years old
  92. Tom is running
  94. ------human-----
  95. I can say, I am 我是人类, 26 years old
  96. 我是人类 is running
  98. ------x-----
  99. I can say, I am 海伦, 18 years old
  100. 海伦 is running
  101. I can say, I am Tom, 18 years old
  102. Tom is running
  103. I can say, I am 我是人类, 26 years old
  104. 我是人类 is running
  106. */

Go 接口

Go 语言中的接口是一组方法的签名，它是 Go 语言的重要组成部分。

定义接口需要使用 interface 关键字，在接口中我们只能定义方法签名，不能包含成员变量。

一个常见的 Go 语言接口是这样的：

定义一个error接口，并定义了Error()方法

  1. type error interface {
  2.     Error() string
  3. }

如果一个类型需要实现 error 接口，那么它只需要实现 Error() string 方法。

下面的 RPCError 结构体就是 error 接口的一个实现

  1. type RPCError struct {
  2.     Code    int64
  3.     Message string
  4. }
  6. func (e *RPCError) Error() string {
  7.     return fmt.Sprintf("%s, code=%d", e.Message, e.Code)
  8. }

心的读者可能会发现上述代码根本就没有 error 接口的影子，这是为什么呢？
Go 语言中接口的实现都是隐式的，我们只需要实现 Error() string 方法就实现了 error 接口。

Go 语言实现接口的方式与 Java 完全不同：

  • 在 Java 中：实现接口需要显式地声明接口并实现所有方法；
  • 在 Go 中：实现接口的所有方法就隐式地实现了接口；

Go 语言中的两种接口

  1. 使用 runtime.iface 表示第一种接口
  2. 使用 runtime.eface 表示第二种不包含任何方法的接口 interface{}

两种接口都使用 interface 声明，但是由于后者在 Go 语言中很常见，所以在实现时使用了特殊的类型。

需要注意的是，与 C 语言中的 void 不同，interface{} 类型*不是任意类型。如果我们将类型转换成了 interface{} 类型，变量在运行期间的类型也会发生变化，获取变量类型时会得到 interface{}。

多态实现

  1. import "fmt"
  3. //定义接口类型
  4. type Humaner interface {
  5.     sayHello()
  6. }
  8. type Teacher struct {
  9.     addr  string
  10.     group string
  11. }
  13. type Student struct {
  14.     name string
  15.     id   int
  16. }
  18. //Student实现了此方法
  19. func (tmp *Student) sayHello() {
  20.     fmt.Printf("Student[%s, %d] sayhi\n", tmp.name, tmp.id)
  21. }
  23. //Teacher实现了此方法
  24. func (tmp *Teacher) sayHello() {
  25.     fmt.Printf("Teacher[%s, %s] sayhi\n", tmp.addr, tmp.group)
  26. }
  28. type MyStr string
  30. //MyStr实现了此方法
  31. func (tmp *MyStr) sayHello() {
  32.     fmt.Printf("MyStr[%s] sayhi\n", *tmp)
  33. }
  35. //定义一个普通函数，函数的参数为接口类型
  36. //只有一个函数，可以有不同表现，多态
  37. func WhoSayHi(i Humaner) {
  38.     i.sayHello()
  39. }
  41. func main() {
  42.     s := &Student{"mike", 666}
  43.     t := &Teacher{"bj", "go"}
  44.     var str MyStr = "hello mike"
  46.     //调用同一函数，不同表现，多态，多种形态
  47.     WhoSayHi(s)
  48.     WhoSayHi(t)
  49.     WhoSayHi(&str)
  51.     ////创建一个切片
  52.     //x := make([]Humaner, 3)
  53.     //x[0] = s
  54.     //x[1] = t
  55.     //x[2] = &str
  56.     //
  57.     ////第一个返回下标，第二个返回下标所对应的值
  58.     //for _, i := range x {
  59.     //    i.sayHello()
  60.     //}
  62. }
  1. package main
  2. import "fmt"
  4. /**
  5. Interface类型可以定义一组方法，但是这些不需要实现。并且interface不能包含任何变量。
  6. interface类型默认是一个指针。
  7. */
  8. type Car interface {
  9.     NameGet() string
  10.     Run(n int)
  11.     Stop()
  12. }
  14. type BMW struct {
  15.     Name string
  16. }
  18. func (this *BMW) NameGet() string  {
  19.     return this.Name
  20. }
  22. func (this *BMW) Run(n int)  {
  23.     fmt.Printf("BMW is running of num is %d \n", n)
  24. }
  26. func (this *BMW) Stop()  {
  27.     fmt.Println("BMW is stop \n")
  28. }
  30. func (this *BMW) ChatUp() {
  31.     fmt.Printf("ChatUp \n")
  32. }
  35. type Benz struct {
  36.     Name string
  37. }
  38. func (this *Benz) NameGet() string {
  39.     return this.Name
  40. }
  41. func (this *Benz) Run(n int) {
  42.     fmt.Printf("Benz is running of num is %d \n", n)
  43. }
  44. func (this *Benz) Stop() {
  45.     fmt.Printf("Benz is stop \n")
  46. }
  47. func (this *Benz) ChatUp() {
  48.     fmt.Printf("ChatUp \n")
  49. }
  52. func main()  {
  53.     var car Car
  54.     fmt.Println(car)         //<nil>
  56.     // 多态 一种事物的多种形态，都可以按照统一的接口进行操作。
  57.     var bmw BMW = BMW{Name:"宝马"}
  58.     car = &bmw
  59.     fmt.Println(car.NameGet())    //宝马
  60.     car.Run(1)                    //BMW is running of num is 1
  61.     car.Stop()                    //BMW is stop
  63.     benz := &Benz{Name:"大奔"}
  64.     car = benz
  65.     fmt.Println(car.NameGet())    //大奔
  66.     car.Run(2)                    //Benz is running of num is 2
  67.     car.Stop()                    //Benz is stop
  69.     //car.ChatUp() //ERROR: car.ChatUp undefined (type Car has no field or method ChatUp)
  70.     benz.ChatUp() //ChatUp
  71. }

值接收者和指针接收者实现接口的区别

接口的另一个微妙之处是接口定义没有规定一个实现者是否应该使用一个指针接收器或一个值接收器来实现接口

值接收者实现接口

  1. package main
  3. import "fmt"
  5. type Mover interface {
  6.     move()
  7. }
  9. type dog struct {}
  12. // 值接收者实现接口
  13. func (d dog) move()  {
  14.     fmt.Println("狗会动")
  15. }
  17. func main()  {
  18.     var m Mover
  20.     var wangcai = dog{}      // 旺财是dog类型
  21.     m = wangcai                // m可以接收dog类型
  22.     m.move()                // 狗会动
  24.     var fugui = &dog{}        // 富贵是*dog类型
  25.     m=fugui                // m可以接收*dog类型
  26.     m.move()                 // 狗会动
  27. }

从上面的代码中我们可以发现，使用值接收者实现接口之后，不管是 dog结构体还是结构体指针*dog类型的变量都可以赋值给该接口变量。

因为Go语言中有对指针类型变量求值的语法糖，dog指针 fugui 内部会自动求值 *fugui。

指针接收者实现接口

  1. package main
  3. import "fmt"
  5. type Mover interface {
  6.     move()
  7. }
  9. type dog struct {}
  11. // 指针接收者实现接口
  12. func (d *dog) move() {
  13.     fmt.Println("狗会动")
  14. }
  16. func main()  {
  17.     var m Mover
  19.     // 指针接收者实现接口 只能接收地址，所以此处会报错
  20.     //var wangcai = dog{}      // 旺财是dog类型
  21.     //m = wangcai            // m可以接收dog类型
  22.     //m.move()                // 狗会动
  24.     var fugui = &dog{}        // 富贵是*dog类型
  25.     m=fugui                // m可以接收*dog类型
  26.     m.move()                 // 狗会动
  27. }

此时实现Mover接口的是 *dog类型，所以不能给m传入 dog类型 的 wangcai，此时 m只能存储 *dog类型的值。

空接口 interface{}

  • 空接口没有定义任何方法
  • 所以任何类型都实现了空接口
  • 可以存储任意类型的数值

它有点类似于C语言的void *类型

  1.     var v1 interface{} = 1                     // 将int类型赋值给interface{}
  2.     var v2 interface{} = "abc"                 // 将string类型赋值给interface{}
  3.     var v3 interface{} = &v2                   // 将*interface{}类型赋值给interface{}
  4.     var v4 interface{} = struct{ X int }{1}
  5.     var v5 interface{} = &struct{ X int }{1}

当函数可以接受任意的对象实例时，我们会将其声明为interface{}
最典型的例子是标准库fmt中PrintXXX系列的函数，例如：

  1. func Printf(fmt string, args ...interface{})
  2. func Println(args ...interface{})
  1. package main
  2. import "fmt"
  4. func print(data interface{}){
  5.     fmt.Printf("data type: %T,          data value: %v, \n", data, data)
  6. }
  8. func printf(data ...interface{}){
  9.     fmt.Printf("data type: %T,      data value: %v, \n", data, data)
  10. }
  12. func main() {
  13.     printf(123, "Who am I")
  16.     //空接口万能类型，保存任意类型的值
  17.     var i interface{} = 1
  18.     print(i)
  20.     i = "abc"
  21.     print(i)
  23.     print([...]int{1, 2, 3})
  24.     print([...]string{"Go"})
  26.     print([]int{10, 20, 30})
  27.     print(make([]int,3,5))
  29.     print(struct {}{})
  31.     print(struct {
  32.         Name string
  33.         Age int
  34.     }{"Tom", 18})
  36.     /*
  37.     data type: []interface {},      data value: [123 Who am I],
  38.     data type: int,                 data value: 1,
  39.     data type: string,              data value: abc,
  40.     data type: [3]int,              data value: [1 2 3],
  41.     data type: [1]string,           data value: [Go],
  42.     data type: []int,               data value: [10 20 30],
  43.     data type: []int,               data value: [0 0 0],
  44.     data type: struct {},           data value: {},
  45.     data type: struct { Name string; Age int },             data value: {Tom 18},
  47.     */
  48. }

类型断言

Golang 中，接口变量的动态类型是变化的，有时我们需要知道一个接口 变量 的动态 类型 究竟是什么?

这就需要使用类型断言，类型断言就是对接口变量的类型进行检查。

那么我们怎么反向知道这个变量里面实际保存了的是哪个类型的对象呢？目前常用的有两种方法：

  • comma-ok断言
  • switch测试

comma-ok断言

语法

  1. value, ok := i.(T)

参数

参数 描述
i interface变量
T 要断言的类型
  • 类型 T 可以为任意一个非接口类型，或者一个任意接口类型。
  • 在一个类型断言表达式 i.(T) 中， i 称为断言值， T 称为断言类型。 一个断言可能成功或者失败。

    返回值

    | 返回值 | 描述 | | —- | —- | | value | 转换后的 数据 | | ok | 转换成功与否的 bool |

说明

  • 将接口 i 转换成 T 类型。
  • 如果转换成功，返回转换成功后的值，即 value，ok 为 true

  • 如果转换失败，value 为 零值，ok 为 false

    类型T说明

  • 如果 T 是具体某个类型，类型断言会检查 i 的动态类型是否等于具体类型 T。如果检查成功，类型断言返回的结果是 i 的动态值，其类型是 T。

  • 如果 T 是接口类型，类型断言会检查 x 的动态类型是否满足 T。如果检查成功，i 的动态值不会被提取，返回值是一个类型为 T 的接口值。
  • 无论 T 是什么类型，如果 i 是 nil 接口值，类型断言都会失败。
  1. package main
  3. import "fmt"
  5. type Student struct {
  6.     name string
  7.     age   int
  8. }
  10. func main() {
  11.     list := make([]interface{}, 3)
  12.     list[0] = 100                                  //int
  13.     list[1] = "Golang"                            //string
  14.     list[2] = Student{"Ueumd", 18}  //Student
  16.     //类型查询，类型断言
  17.     for index, data := range list {
  19.         if value, ok := data.(int); ok == true {
  20.             fmt.Printf("list[%d]=%v,         type: %T\n", index, value, value)
  21.         } else if value, ok := data.(string); ok == true {
  22.             fmt.Printf("list[%d]=%v,     type: %T\n", index, value, value)
  23.         } else if value, ok := data.(Student); ok == true {
  24.             fmt.Printf("list[%d]=%v,     type: %T\n", index, value, value)
  25.         }
  26.     }
  28.     /*
  29.     list[0]=100,            type: int
  30.     list[1]=Golang,         type: string
  31.     list[2]={Ueumd 18},     type: main.Student
  32.     */
  33. }

switch测试

  1.     for index, data := range list {
  2.         switch value := data.(type) {
  3.         case int:
  4.             fmt.Printf("list[%d]=%v,         type: %T\n", index, value, value)
  5.         case string:
  6.             fmt.Printf("list[%d]=%v,     type: %T\n", index, value, value)
  7.         case Student:
  8.             fmt.Printf("list[%d]=%v,     type: %T\n", index, value, value)
  9.         }
  10.     }
  12.     /**
  13.     list[0]=100,            type: int
  14.     list[1]=Golang,         type: string
  15.     list[2]={Ueumd 18},     type: main.Student
  16.     */

参考
https://segmentfault.com/a/1190000038552939