Hi， 今天和大家一起学习Go语言的接口。

像Channel和协程一样，Go语言的接口设计也是其一大特色。不像Java、C++、PHP等语言，一个类要实现接口必须明确声明，在Go语言中一个类型只要实现了接口中的方法，就认为该类型实现了此接口。这种更加松散的实现方式，使面向对象编程变得更加简单。

声明接口

type 接口名称 interface{
    方法一(传入参数) (返回值)
    方法二(传入参数) (返回值)
}

通过type 接口名称 interface来声明一个接口，在后面的大括号中定义实现接口需要的方法。Go语言的接口只有方法，没有属性。只要实现了所有方法的类型都可以认为实现了此接口，也被戏称Duck typing。

Duck typing：如何判断一个动物是不是鸭子呢？如果一个动物走路、叫声、羽毛、形体和鸭子一样，我们就认为它是一只鸭子。引申一下就是通过判断一个对象的外表和动作决定它的类型。

基本用法

实现接口

例1：

// 声明Dog接口，包含getAge方法
type Dog interface{
   getAge()
}

type Jinmao struct {
   age int
}

func (j Jinmao) getAge()  {
   fmt.Printf("I am %d years old!",j.age)
}

func main()  {
   a1 := Jinmao{age:2}
   var d Dog= a1 // 声明Dog类型的实例d，并把a1赋值给d
   d.getAge()// print：I am 2 years old!
}

如上示例，我们声明了Dog接口，Dog接口只包含getAge()方法。接着又定义了Jinmao结构体，Jinmao也实现了getAge方法，所以我们就可以说Jinmao实现了Dog接口。我们定义a1为Jinmao类型，接着定义d为Dog类型，因为a1所属类型实现了Dog接口，所以我们可以把a1赋值给d，d在调用getAge方法时，就会调用Jinmao实现的方法。

示例中有一个关键点需要留意：Jinmao结构体实现的getAge方法不仅仅名称和Dog的getAge方法一致，传入参数和返回值也必须完全一致，才认为Jinmao实现了Dog接口定义的getAge方法。

在Go语言中接口类型的零值是nil。

接口作用

在例1中我们虽然实现了接口，但是并没有体现出使用接口的价值。例2：

// 声明Dog接口，包含getAge方法
type Dog interface{
   getAge() int
}

type Jinmao struct {
   age int
}

func (j Jinmao) getAge() int {
   return j.age
}

type Husky struct {
   age int
}

func (h Husky) getAge() int {
   return h.age
}

// 计算所有的年龄和
func AddAge(s []Dog) int {
   var sum int
   for _,v := range s{
      sum += v.getAge()
   }
   return sum
}

func main()  {
   a1 := Jinmao{age:2}
   var d1 Dog= a1 // 声明Dog类型的实例d1，并把a1赋值给d

   a2 := Husky{age: 3}
   var d2 Dog = a2 // 声明Dog类型的实例d2，并把a2赋值给d

   ageSum := AddAge([]Dog{d1,d2})
   fmt.Printf("狗狗年龄之和是：%d", ageSum)
}

如上示例中，我们声明了Jinmao和Husky两个类型且都实现了Dog接口。方法AddAge接收元素为Dog类型的切片。我们声明a1是Jinmao类型并赋值给d1，a2是Husky类型并赋值给d2。接下来调用AddAge方法时候，在AddAge方法内部遍历各Dog类型的元素并调用getAge方法，元素会根据自己被赋予的实际类型执行各自的方法。

实际类型就是接口被赋予的实现此接口实际对象的类型。如例2中的var d1 Dog= a1，d1的类型就是a1（实际对象）所属的类型，a1属于Jinmao，所以Jinmao就是d1的实际类型。

继续思考以上示例，我们增加Teddy类型，并实现Dog接口。当我们调用AddAge方法时，方法内部不用做任何修改。这就是接口给我们带来的好处。

接口类型

例3：

// 声明Dog接口，包含getAge方法
type Dog interface{
   getAge() int
}

type Jinmao struct {
   age int
}

func (j Jinmao) getAge() int {
   return j.age
}

func main()  {
   a1 := Jinmao{age:2}
   var d1 Dog= a1 // 声明Dog类型的实例d1，并把a1赋值给d
   fmt.Printf("d1的类型是：%T", d1) // d1的类型是：main.Jinmao
}

在fmt包的Printf方法中，%T代表d1的类型。最终输出d1的实际类型是Jinmao。

空接口

我们用interface{}表示空接口。根据Go语言中接口的定义，实现了接口方法的对象都是接口的实现类型，空接口没有定义方法，那也 就意味着所有类型都实现了空接口。

当方法可以接收任意类型的参数时，可以使用interface{}表示。

高级用法

接口类型

例4：

// 声明Dog接口，包含age方法
type Dog interface{
   getAge() int
}

type Jinmao struct {
   age int
}

func (j Jinmao) getAge() int {
   return j.age
}

func main()  {
   a1 := Jinmao{age:2}
   var d1 Dog= a1 // 声明Dog类型的实例d1，并把a1赋值给d
   v,ok := d1.(Jinmao) // 判断d1的实际类型是否是Jinmao
   fmt.Printf("v=%v,ok=%v",v,ok) // print v={2},ok=true
}

如上示例，我们通过v,ok := d1.(Jinmao)判断d1的实际类型。 一种更常见的方法是通过switch case语句判断数据的实际类型。 例5：

// 声明Dog接口，包含getAge方法
type Dog interface{
   getAge() int
}

type Jinmao struct {
   age int
}

func (j Jinmao) getAge() int {
   return j.age
}

type Husky struct {
   age int
}

func (h Husky) getAge() int {
   return h.age
}

func assertType(i interface{}){
   switch i.(type) {
   case Jinmao:
      fmt.Println("实际类型是Jinmao")
   case Husky:
      fmt.Println("实际类型是Husky")
   case int:
      fmt.Println("实际类型是int")
   default:
      fmt.Println("未匹配到类型")
   }
}

func main()  {
   a1 := Jinmao{age:2}
   var d1 Dog= a1 // 声明Dog类型的实例d1，并把a1赋值给d

   assertType(a1) // print 实际类型是Jinmao
   assertType(d1) // print 实际类型是Jinmao
   assertType(100) // print 实际类型是int
   assertType("str") // print 未匹配到类型
}

在例5中我们可以看到，如何通过switch i.(type){}语句判断变量的实际类型。

值类型和指针类型方法

在讲方法的时候我们说到有值类型和指针类型的方法，这两种类型的方法在实现接口时有何不同呢？ 例6：

// 声明Dog接口，包含age方法
type Dog interface{
   getAge() int
}

type Jinmao struct {
   age int
}

func (j Jinmao) getAge() int {
   return j.age
}

type Husky struct {
   age int
}

func (h *Husky) getAge() int {
   return h.age
}

func main()  {
   a1 := Jinmao{age:2}
   var d1 Dog= a1 // 声明Dog类型的实例d1，并把a1赋值给d1

   a2 := Jinmao{age:3}
   var d2 Dog= &a2 // 声明Dog类型的实例d1，并把a1赋值给d2

   //a3 := Husky{age:2}
   //var d3 Dog= a3 // 声明Dog类型的实例d1，并把a1赋值给d3

   a4 := Husky{age:4}
   var d4 Dog= &a4 // 声明Dog类型的实例d1，并把a1赋值给d4

   fmt.Println(d1.getAge()) // print 2
   fmt.Println(d2.getAge()) // print 3
   // fmt.Println(d3.getAge())
   fmt.Println(d4.getAge()) // print 4
}

在上面的示例中，Jinmao的值类型实现了getAge()，a1是Jinmao的值类型，&a2是Jinmao的指针类型，a1和a2都可以赋值给Dog类型的值。Husky的指针类型实现了getAge(),a3是Husky的值类型，&a4是Husky的指针类型，此时只有&a4可以赋值Dog类型的d4。如果把a3赋值给d3会报编译时错误 Type does not implement 'Dog' as 'getAge' method has a pointer receiver。这是Go语言值类型方法和指针类型方法的特点，我们可以这样理解对象值类型的方法，也自动包含了指针类型的方法；而指针类型的方法不含值类型的方法。

对象值类型的方法，也自动包含了指针类型的方法是因为Go语言在编译期做了优化。

接口嵌套

接口之间可以通过嵌套实现类似于继承的效果。 例7：

// 声明Dog接口，包含getAge方法
type Dog interface{
   getAge() int
}

// 声明Cat接口，包含getName方法
type Cat interface {
   getName() string
}
// Animal接口，嵌套了Dog和Cat接口
type Animal interface {
   Dog
   Cat
}

type Husky struct {
   age int
   name string
}

func (h Husky) getAge() int {
   println("I am Husky getAge!")
   return h.age
}

func (h Husky) getName() string {
   println("I am Husky getName!")
   return h.name
}

type OrangeCat struct {
   age int
   name string
}

func (o OrangeCat) getAge() int {
   println("I am OrangeCat getAge!")
   return o.age
}

func (o OrangeCat) getName() string {
   println("I am OrangeCat getName!")
   return o.name
}

func main()  {
   h1 := Husky{age:2,name:"xiaohei"}
   var a1 Animal= h1 // 声明Dog类型的实例d1，并把a1赋值给d1

   o1 := OrangeCat{age:1, name:"Tom"}
   var a2 Animal= o1 // 声明Dog类型的实例d1，并把a1赋值给d2

   fmt.Println(a1.getAge())
   fmt.Println(a1.getName())
   fmt.Println(a2.getAge())
   fmt.Println(a2.getName())
}

执行例6的代码，输出如下结果：

I am Husky getAge!
2
I am Husky getName!
xiaohei
I am OrangeCat getAge!
0
I am OrangeCat getName!
Tom

在例6中我们声明Animal接口包含了Dog和Cat接口，要想实现Animal接口就需要实现Dog和Cat接口的所有方法。我们给Husky和OrangeCat结构体类型都实现了getAge和getName方法，所以a1和a2可以被h1和o1赋值。

接口赋值

接口赋值对于值类型和指针类型有所不同，请看下面的例子。 例8：

// 声明Dog接口，包含getAge方法
type Dog interface{
   getAge() int
}

type Jinmao struct {
   age int
}

func (j *Jinmao) setAge(i int) {
   j.age = i
}

func (j Jinmao) getAge() int {
   return j.age
}

func main()  {
   a1 := Jinmao{age:2}
   var d1 Dog= a1 // 声明Dog类型的实例d1，并把a1赋值给d1
   a1.setAge(20)
   fmt.Printf("a1.age=%d \n",a1.getAge())
   fmt.Printf("d1.age=%d \n",d1.getAge())

   a2 := Jinmao{age:3}
   var d2 Dog= &a2 // 声明Dog类型的实例d2，并把a2赋值给d2
   a2.setAge(30)
   fmt.Printf("a1.age=%d \n",a2.getAge())
   fmt.Printf("a1.age=%d \n",d2.getAge())
}

执行上面例8中的代码输出如下：

a1.age=20 
d1.age=2 
a1.age=30 
a1.age=30 

通过结果我们可以看出，对a1调用setAge方法并没有改变d1的age；对a2调用setAge方法改变了d2的age。在Go语言中的赋值操作都是值拷贝， 但是d2拷贝的是a2的地址，所以d2和a2还是指向同一个内存地址，当a2的age改变时d2的age也改变了。

总结

本文我们主要介绍了Go语言接口的基本用法、嵌套使用、赋值原理等。接口在Go语言中极具特色，而且在面向对象编程中使用广泛。如果大家对文章内容有任何疑问或建议，欢迎私信交流。

我把Go语言基础知识相关文章的Demo都放到了下面这个仓库中，方便大家互相交流学习。https://github.com/jialj/golang-teach