Go 小技巧之接口嵌套与实现

接口嵌套与实现

• 接口的嵌套就相当于，函数数量的累加

  • type Print3 interface {
    	Print2
    	PrintSingle
    }
    

  • 要实现 Print3 接口就相当于实现 print1，print2，print3 函数

• 结构体嵌套

  • 父结构体实现了接口就相当于子结构体实现了接口
    • device 实现了 Print2 接口，其子结构体 device2 也实现了此接口
  • 子结构体可以调用父结构体中的数据
    • device2 可使用父结构体 device 中的 str 数据
  • 接口的实现主要就是看，结构体所拥有的的函数数量 是否等于 接口定义的函数数量
    • device 实现了 Print2 接口
    • device2 实现了PrintSingle接口
    • 因此 device2 可调用父结构体的所有函数，实现了所有接口，即实现了Print3接口
  • 子结构体可定义父结构体同名函数，从而实现功能覆盖
    • device2 实现了 print2 函数，覆盖了父结构体device 的print2 函数

import (
	"fmt"
)

// 父结构体 device
type device struct {
	str string
}

// 子结构体 device2
type device2 struct {
	device // 嵌套父结构体 device
	demo   string
}
type Print2 interface {
	print1()
	print2()
}

// 实现 Print2 接口
func (d device) print1() {
	fmt.Println("这是测试1")
	fmt.Println(d.str)
}
func (d device) print2() {
	fmt.Println("这是测试2")
	fmt.Println(d.str)
}

type PrintSingle interface {
	print3()
}

// 接口嵌套  实现此结构体 需要实现三个函数 print1  print2  print3
type Print3 interface {
	Print2
	PrintSingle
}

func (d device2) print3() {
	fmt.Println("这是测试3")
	fmt.Println("子结构体device2 可以调用 父结构体device任意数据")
	// 注意 str 是 父结构体 device 的数据，子结构体可以调用
	fmt.Println(d.str)
	fmt.Println(d.demo)
}

func (d device2) print2() {
	fmt.Println("测试是否覆盖父结构体 device 的同名函数")
	fmt.Println("这是子结构体 device2 的测试2，打印出此句证明成功覆盖")
}

func main() {
	// 验证 结构体是否实现了接口
	var _ Print2 = device{}
	var _ Print2 = device2{}
	test := device2{
		device{"来自父结构体 device"},
		"来自子结构体 device2",
	}
	test.print1()
	//var _ Print3 = device{}  // 去掉注释 会提示未实现 print3 方法 未实现接口
	// device2 实现了 Print3 接口
	// 父结构体 device  实现了 print1 print2 函数
	// 子结构体 device2 实现了 print3 函数
	// 所以只要满足接口函数的数量，就可以认定为实现了接口
	var _ Print3 = device2{}
	fmt.Println("-------")
	test.print3()
	fmt.Println("-------")
	test.print2()
}

上面代码的输出为：

这是测试1
来自父结构体 device
-------
这是测试3
子结构体device2 可以调用 父结构体device任意数据
来自父结构体 device
来自子结构体 device2
-------
测试是否覆盖父结构体 device 的同名函数
这是子结构体 device2 的测试2，打印出此句证明成功覆盖