Go语言的接口详解

接口就是一系列方法的集合（规范行为）

在面向对象的领域里，接口一般这样定义：接口定义一个对象的行为，规范子类对象的行为。

在 go 语言中的接口是非侵入式接口（接口没了，不影响代码），侵入式接口（接口没了，子类报错）

go 也是鸭子类型，比如我现在有个鸭子类，内有 speak 方法和 run 方法，子类只要实现了 speak 和 run，我就认为子类是鸭子，我只要子类中有这两个方法你就是鸭子，有这两个方法你就是鸭子，他是从下往上推导只要有你这里面的东西，那就是算是继承了你这个接口

1、接口的用途

接口是一个类型

// duck 定义一个鸭子接口
type duck interface {
   speak()
   run()
}

// whiteduck 定义一个白鸭子结构体
type whiteduck struct {
   name  string
   age int
   sex string
}

// blackduck 定义一个黑鸭子结构体
type blackduck struct {
   name  string
   age int
   sex string
}

// 让白鸭子和黑鸭子绑定接口中的所有方法，就叫实现该接口
// 让白鸭子实现 duck 接口
func (w whiteduck) speak() {
   fmt.println("白鸭子嘎嘎叫，它的名字叫", w.name)
}

func (w whiteduck) run() {
   fmt.println("白鸭子慢悠悠的走，它的名字叫", w.name)
}

// 让黑鸭子实现 duck 接口
func (b blackduck) speak() {
   fmt.println("黑鸭子呱呱叫，它的名字叫", b.name)
}

func (b blackduck) run() {
   fmt.println("黑鸭子歪歪扭扭的走，它的名字叫", b.name)
}


func main() {
   var duck duck
   duck = whiteduck{"小白", 15, "男"}	// 把我的对象赋值给一个接口类型，就可以实现多态的效果
   fmt.println(duck)
    
   // duck 现在他是一个接口，它只能取方法，不能取出属性了。
   duck.speak()
   duck.run()
}

// 输出：
{小白 15 男}
白鸭子嘎嘎叫，它的名字叫 小白
白鸭子慢悠悠的走，它的名字叫 小白

2、类型断言

用于提取接口的底层值，就是把接口类型转成 struct ，属性，自有方法也有了。

func main() {
	var duck duck = whiteduck{"小白", 15, "男"}
	// 断言是 whiteduck 类型
	value, ok := duck.(whiteduck)
	// 断言成功，ok=true，value就是whiteduck结构体对象
	fmt.println(value)		// 输出：{小白 15 男}
	fmt.println(value.name)	// 输出：小白
	fmt.println(ok)			// 输出：true

	// 断言失败，ok1=false，value1是blackduck类型的空值，因为没有赋值
	value1, ok1 := duck.(blackduck)
	fmt.println(value1)		// 输出：{ 0 }
	fmt.println(ok1)		// 输出：false
}

3、类型选择

（通过 type switch ）

用于将接口的具体类型与很多 case 语句所指定的类型进行比较。

func main() {
   var duck duck = whiteduck{"小白", 15, "男"}
   test(duck)
}

func test(duck duck) {
   switch value := duck.(type) {
   case whiteduck:
      fmt.println(value.name)
      fmt.println("我是白鸭子")
   case blackduck:
      fmt.println(value.name)
      fmt.println("我是黑鸭子")
   default:
      fmt.println(value)
      fmt.println("我是鸭子这个类")
   }
}

4、空接口

没有任何方法，所有数据类型都实现了空接口

type empty interface {} // 空接口

func main() {
   var a int = 10
   var b string = "xiaoyang"
   var c [3]int
   var e empty    // e是空接口类型,可以接受任意的数据类型
   e = a
   e = b
   e = c
    
   // 这样的话需要把它类型选择回来
   // 正常情况下我只能接收 empty 类型的，但是 a b c 都不是 empty 类型的
   test(a)	// 输出：我是int 10
   test(b)	// 输出：我是字符串 xiaoyang
   test(c)	// 输出：我是数组 [0 0 0]
}

// 如果这不是一个空接口，比如是 duck 那么只要实现了 duck 接口的所有数据类型都可以传
func test(b empty)  {		
   switch v:=b.(type) {
   case string:
      fmt.println("我是字符串", v)
   case int:
      fmt.println("我是int", v)
   case [3]int:
      fmt.println("我是数组", v)
   }
}

5、匿名空接口

没有名字的空接口，一般用在形参上

func main() {
   var duck duck = whiteduck{"小白", 15, "男"}
   test(10)
   test("xiaoyang")
   test(duck)
}

// 这叫匿名空接口，所有数据类型都可以往里面传，如果想用原来的结构体还需要类型选择回来才能用
func test(b interface{}) {
   fmt.println(b)
}

6、实现多个接口

// duck 定义一个鸭子接口
type duck interface {
   speak()
   run()
}

type animal interface {
   eat()
   sleep()
}

// whiteduck 定义一个白鸭子结构体
type whiteduck struct {
   name string
   age  int
   sex  string
}


// 让白鸭子即实现 duck 接口也实现了 animal 接口
func (w whiteduck) speak() {
   fmt.println("白鸭子嘎嘎叫，它的名字叫", w.name)
}

func (w whiteduck) run() {
   fmt.println("白鸭子慢悠悠的走，它的名字叫", w.name) 
}

func (w whiteduck) eat() {
   fmt.println("白鸭子吃饭，它的名字叫", w.name)
}

func (w whiteduck) sleep() {
   fmt.println("白鸭子睡觉，它的名字叫", w.name)
}


func main() {
	var w whiteduck = whiteduck{}
	var a animal
	var d duck

	// 这样的话我的 w 即可以给 a ，也可以给 d
	// 但是一旦转到某个接口上，只能使用该接口的方法，自身属性和自身方法需要类型断言后才能使用
	
	a = w		// w 给了 a ，那么 a 就只能调用 animal 接口的方法
	a.sleep()
	a.eat()
	
	d = w		// w 给了 d ，那么 a 就只能调用 duck 接口的方法
	d.run()
	d.speak()
}

7、接口嵌套

type duck interface {
   animal    // duck 嵌套 animal 接口
   speak()
   run()
}

type animal interface {
   eat()
   sleep()
}

type whiteduck struct {
   name string
   age  int
   sex  string
}


// 这样白鸭子即实现 duck 接口也实现了 animal 接口
func (w whiteduck) speak() {
   fmt.println("白鸭子嘎嘎叫，它的名字叫", w.name)
}

func (w whiteduck) run() {
   fmt.println("白鸭子慢悠悠的走，它的名字叫", w.name)
}
func (w whiteduck) eat() {
   fmt.println("白鸭子嘎嘎叫，它的名字叫", w.name)
}

func (w whiteduck) sleep() {
   fmt.println("白鸭子慢悠悠的走，它的名字叫", w.name)
}



func main() {
   var a animal
   var d duck
   var w whiteduck = whiteduck{}

   // w 即可以给 a，也可以给 d
   a = w     // 但是 a 只能调用 animal 中的两个方法
   a.sleep()
   a.eat()

   d = w     // d 却能调用 duck 和 animal 中的四个方法
   d.sleep()
   d.eat()
   d.speak()
   d.run()
}

8、接口零值

func main() {

   var a animal   // nil 就是说明它是一个引用类型
   // 其内部表示就已经告诉了我们，它里面就存两个值，一个是它的类型，一个是指向具体值的指针

   fmt.println(a) // 输出：<nil>
}

9、make和new的区别

type whiteduck struct {
   name string
   sex  string
   age  int
}

func main() {
   var per1 *whiteduck = new(whiteduck) // new 是返回指向这个类型的指针
   // 或者是我取 whiteduck 的地址，赋值给 per2
   var per2 = &whiteduck{}

   fmt.println(per1)  // 输出：&{  0}
   fmt.println(per2)  // 输出：&{  0}

   var per3 = make([]int, 3, 4)   // make 是具体的创建引用类型
                           // new 是创建指向这个类型的指针
   var per4 = new([]int)        // 是一个指向切片类型的指针

   fmt.println(per3)  // 输出：[0 0 0]
   fmt.println(per4)  // 输出：&[]
}

总结

本篇文章就到这里了，希望能够给你带来帮助，也希望您能够多多关注的更多内容！