接口interface

接口interface
定义：接口是一种抽象的类型，是一组method的集合，里头只有method方法，没有数据成员。当两个或两个以上的类型都有相同的处理方法时才需要用到接口。先定义接口，然后多个struct类型去实现接口里的方法，就可以通过接口变量去调用struct类型里实现的方法。

比如动物都会叫唤，那可以先定义一个名为动物的接口，接口里有叫唤方法speak，然后猫和狗这2个struct类型去实现各自的speak方法。

语法：

// 定义接口
type interface_name interface {
method_name1([参数列表]) [返回值列表]
method_name2([参数列表]) [返回值列表]
method_nameN([参数列表]) [返回值列表]
}

// 定义结构体类型
type struct_name struct {
data_member1 data_type
data_member2 data_type
data_memberN data_type
}

// 实现接口interface_name里的方法method_name1
func(struct_var struct_name) method_name1([参数列表])[返回值列表] {
/具体方法实现/
}

// 实现接口interface_name里的方法method_name2
func(struct_var struct_name) method_name2([参数列表])[返回值列表] {
/具体方法实现/
}

/* 实现接口interface_name里的方法method_name3
注意：下面用了指针接受者。函数可以使用值接受者或者指针接受者，上面的method_name1和method_name1使用的是值接受者。
如果用了指针接受者，那给interface变量赋值的时候要传指针
*/
func(struct_var *struct_name) method_name3([参数列表])[返回值列表] {
/具体方法实现/
}

示例：

package main

import “fmt”

// all animals can speak
type Animal interface {
speak()
}

// cat
type Cat struct {
name string
age int
}

func(cat Cat) speak() {
fmt.Println(“cat miaomiaomiao”)
}

// dog
type Dog struct {
name string
age int
}

func(dog *Dog) speak() {
fmt.Println(“dog wangwangwang”)
}

func main() {
var animal Animal = Cat{“gaffe”, 1}
animal.speak() // cat miaomiaomiao

/*
因为Dog的speak方法用的是指针接受者，因此给interface赋值的时候，要赋指针
*/
animal = &Dog{"caiquan", 2}
animal.speak() // dog wangwangwang

}
struct结构体类型在实现interface里的所有方法时，关于interface变量赋值有2个点要注意

只要有某个方法的实现使用了指针接受者，那给包含了这个方法的interface变量赋值的时候要使用指针。比如上面的Dog类型要赋值给Animal，必须使用指针，因为Dog实现speak方法用了指针接受者。

如果全部方法都使用的是值接受者，那给interface变量赋值的时候用值或者指针都可以。比如上面的例子，animal的初始化用下面的方式一样可以：

var animal Animal = &Cat{“gaffe”, 1}
多个struct类型可以实现同一个interface：多个类型都有共同的方法(行为)。比如上面示例里的猫和狗都会叫唤，猫和狗就是2个类型，叫唤就是speak方法。

一个struct类型可以实现多个interface。比如猫这个类型，既是猫科动物，也是哺乳动物。猫科动物可以是一个interface，哺乳动物可以是另一个interface，猫这个struct类型可以实现猫科动物和哺乳动物这2个interface里的方法。

package main

import “fmt”

// interface1，猫科动物的共同行为
type Felines interface {
feet()
}

// interface2, 哺乳动物的共同行为
type Mammal interface {
born()
}

// 猫既是猫科动物也是哺乳动物，2个行为都实现
type Cat struct {
name string
age int
}

func(cat Cat) feet() {
fmt.Println(“cat feet”)
}

func(cat *Cat) born() {
fmt.Println(“cat born”)
}

func main() {
cat := Cat{“rich”, 1}
var a Felines = cat
a.feet()

var b Mammal = &cat
b.born()

}
interface可以嵌套：一个interface里包含其它interface

package main

import “fmt”

// interface1
type Felines interface {
feet()
}

// interface2, 嵌套了interface1
type Mammal interface {
Felines
born()
}

// 猫实现Mammal这个interface里的所有方法
type Cat struct {
name string
age int
}

func(cat Cat) feet() {
fmt.Println(“cat feet”)
}

func(cat *Cat) born() {
fmt.Println(“cat born”)
}

func main() {
cat := Cat{“rich”, 1}
/Mammal有feet和born方法，2个都可以调用/
var a Mammal = &cat
a.feet()
a.born()

var b Felines = cat
b.feet()
// b.born() 调用这个会编译报错，因为Felines没有born方法

}
空接口interface

如果空interface作为函数参数，可以接受任何类型的实参

语法

func function_name(x interface{}) {
do sth
}

• 示例

  package main
  
  import "fmt"
  
  
  type Cat struct {
      name string
      age int
  }
  
  // 打印空interface的类型和具体的值
  func print(x interface{}) {
      fmt.Printf("type:%T, value:%v\n", x, x)
  }
  
  func main() {
      // 传map实参给空接口
      dict := map[string]int{"a":1}
      print(dict) // type:map[string]int, value:map[a:1]
      
      // 传struct实参给空接口
      cat := Cat{"nimo", 2}
      print(cat) // type:main.Cat, value:{nimo 2}
  }
  

如果空interface作为变量，可以把任何类型的变量赋值给空interface

语法

var x interface{} // 空接口x
示例

package main

import “fmt”

type Cat struct {
name string
age int
}

// 打印空interface的类型和具体的值
func print(x interface{}) {
fmt.Printf(“type:%T, value:%v\n”, x, x)
}

func main() {
// 定义空接口x
var x interface{}
// 将map变量赋值给空接口x
x = map[string]int{“a”:1}
print(x) // type:map[string]int, value:map[a:1]

// 传struct变量估值给空接口x
cat := Cat{"nimo", 2}
x = cat
print(x) // type:main.Cat, value:{nimo 2}

}
空接口作为map的值，可以实现map的value是不同的数据类型

语法

// 定义一个map类型的变量，key是string类型，value是空接口类型
dict := make(map[string]interface{})

• 示例

  package main
  
  import "fmt"
  
  
  func main() {
      // 定义一个map类型的变量，key是string类型，value是空接口类型
      dict := make(map[string]interface{})
      // value可以是int类型
      dict["a"] = 1 
      // value可以是字符串类型
      dict["b"] = "b"
      // value可以是bool类型
      dict["c"] = true
      fmt.Println(dict) // map[a:1 b:b c:true]
      fmt.Printf("type:%T, value:%v\n", dict["b"], dict["b"]) // type:string, value:b
  }
  

x.(T)

断言：断言接口变量x是T类型

语法：value是将x转化为T类型后的变量，ok是布尔值，true表示断言成功，false表示断言失败

// x是接口变量，如果要判断x是不是
value, ok := x.(string)
示例

var x interface{}
x = “a”
// 断言接口变量x的类型是string
v, ok := x.(string)
if ok {
// 断言成功
fmt.Println(“assert true, value:”, v)
} else{
// 断言失败
fmt.Println(“assert false”)
}
动态判断数据类型

package main

import “fmt”

func checkType(x interface{}) {
/动态判断x的数据类型/
switch v := x.(type) {
case int:
fmt.Printf(“type: int, value: %v\n”, v)
case string:
fmt.Printf(“type: string，value: %v\n”, v)
case bool:
fmt.Printf(“type: bool, value: %v\n”, v)
case Cat:
fmt.Printf(“type: Cat, value: %v\n”, v)
case map[string]int:
fmt.Printf(“type: map[string]int, value: %v\n”, v)
v[“a”] = 10
default:
fmt.Printf(“type: %T, value: %v\n”, x, x)
}
}

type Cat struct {
name string
age int
}

func main() {
var x interface{}
x = “a”
checkType(x) //type: string，value: a

x = Cat{"hugo", 3}
checkType(x) // type: Cat, value: {hugo 3}

/*在checkType里对map做修改
会影响外面的实参x
*/
x = map[string]int{"a":1}
checkType(x) // type: map[string]int, value: map[a:1]
fmt.Println(x) // map[a:10]

}
注意事项

如果把一个结构体变量赋值给interface变量，那结构体需要实现interface里的所有方法，否则会编译报错：xx does not implement yy，表示结构体xx没有实现接口yy