Go学习(十四):面向对象-接口(interface)

虽然Go语言没有继承和多态，但是Go语言可以通过匿名字段实现继承，通过接口实现多态。

1.介绍

1.1 概念

在Go语言中，接口是一组方法签名。接口指定了类型应该具有的方法，类型决定了如何实现这些方法。当某个类型为接口中的所有方法提供了具体的实现细节时，这个类型就被称为实现了该接口。接口定义了一组方法，如果某个对象实现了该接口的所有方法，则此对象就实现了该接口。

1.2 声明语法

type 接口名称 interface {
    Method1([参数列表]) [返回值列表]
    Method2([参数列表]) [返回值列表]
    ...
}

示例

// 定义一个接口
type Bird interface {
	fly() // 无参数无返回值方法
	eat(string2 string) // 有参数无返回值方法
	walk(string2 string) string // 有参数有返回值方法
}

2.定义和实现

2.1 定义接口

// 定义一个鸟类接口
type Birder interface {
	fly()  
	eat(food string)
}

2.2 实现接口

Go没有implements或extends关键字,类型都是隐式实现接口的。任何定义了接口中所有方法的类型都被称为隐式地实现了该接口。

package main
import "fmt"
// 定义一个鸟类接口
type Birder interface {
	fly()
	eat(food string)
}
// 定义乌鸦结构体
type Crow struct {
	name string
}
// -------- 下面开始实现Bird接口 ------
func (c Crow) fly() {
	fmt.Printf("我是 %s,我会飞....\n", c.name)
}
func (c Crow) eat(food string) {
	fmt.Printf("我是 %s,我喜欢吃 %s \n", c.name,food)
}
// -------- 实现鸟类接口的所有方法，就代表实现了接口 ------
func main() {
	crow := Crow{"乌鸦"}
	crow.fly()
	crow.eat("谷子")
}
/** 输出
  我是 乌鸦,我会飞....
  我是 乌鸦,我喜欢吃 谷子 
*/

3. 模拟多态

3.1 什么是多态?

如果有几个相似而不完全相同的对象，有时人们要求在向它们发出同一个消息时，它们的反应各不相同，分别执行不同的操作，这种情况就是多态现象。Go语言中的多态性是在接口的帮助下实现的——定义接口类型，创建实现该接口的结构体对象。

3.2 使用示例

定义接口类型的对象，可以保存实现该接口的任何类型的值。Go语言接口变量的这个特性实现了Go语言中的多态性。

实现: 写一个函数，接收不同类型的结构体，并打印不同其方法。

package main
import "fmt"
// 定义一个飞行器接口
type Flying interface {
	getName() string
}
// 定义小鸟结构体
type bird struct {
  name string
}
// bird实现接口
func (b bird) getName() string {
	return b.name
}
// 定义飞机结构体
type aircraft struct {
	name string
}
// aircraft实现接口
func (a aircraft) getName() string {
	return a.name
}
// 定义ufo结构体
type ufo struct {
	name string
}
// ufo实现接口
func (u ufo) getName() string {
	return u.name
}
// 写一个函数，接收不同类型的结构体，并打印不同其方法。
func print(flyList []Flying)  {
	for _,v := range flyList {
		fmt.Printf("我是%s,我会飞.....\n",v.getName())
	}
}
func main() {
	// 定义一个接口切片
	flyList := make([]Flying,0,3)
	bird := bird{"小鸟"}
	aircraft := aircraft{"飞机"}
	ufo := ufo{"UFO"}
	flyList = append(flyList, bird,aircraft,ufo)
	fmt.Printf("len: %d cap:%d val: %v \n",len(flyList),cap(flyList),flyList)
	// 调用函数
	print(flyList)
}
/** 输出
  len: 3 cap:3 val: [{小鸟} {飞机} {UFO}] 
  我是小鸟,我会飞.....
  我是飞机,我会飞.....
  我是UFO,我会飞.....
*/

4.空接口

空接口是接口类型的特殊形式，空接口没有任何方法，因此任何类型都无须实现空接口。从实现的角度看，任何值都满足这个接口的需求。因此空接口类型可以保存任何值，也可以从空接口中取出原值。

4.1 定义空接口

// 定义一个空接口
type A interface {}

4.2 保存任意类型

package main
import "fmt"
// 定义一个空接口
type A interface {
}
func main() {
	// 声明变量
	var a A
	// 保存整型
	a = 10
	fmt.Printf("保存整型: %v \n", a)
	// 保存字符串
	a = "hello word"
	fmt.Printf("保存字符串: %v \n", a)
	// 保存数组
	a = [3]float32{1.0, 2.0, 3.0}
	fmt.Printf("保存数组: %v \n", a)
	// 保存切片
	a = []string{"您", "好"}
	fmt.Printf("保存切片: %v \n", a)
	// 保存Map
	a = map[string]int{
		"张三": 22,
		"李四": 25,
	}
	fmt.Printf("保存map: %v \n", a)
	// 保存结构体
	a = struct {
		name string
		age  int
	}{"王麻子", 40}
	fmt.Printf("保存结构体: %v \n", a)

	// 声明一个空接口切片
	var aa []A
	// 保存任意类型数据到切片中
	aa = append(aa, 23, []string{"php", "go"}, map[string]int{"a": 1, "b": 2}, struct {
		city,province string

	}{"合肥","安徽"})
	fmt.Printf("空接口切片: %v \n", aa)
}

/** 输出:
  保存整型: 10 
  保存字符串: hello word 
  保存数组: [1 2 3] 
  保存切片: [您 好] 
  保存map: map[张三:22 李四:25] 
  保存结构体: {王麻子 40} 
  空接口切片: [23 [php go] map[a:1 b:2] {合肥 安徽}] 
*/

4.3 从空接口中取值

保存到空接口的值，如果直接取出指定类型的值时，会发生编译错误。

错误示例:

package main
import "fmt"
// 定义一个空接口
type I interface {
}

func main() {
	// 声明变量num
	num := 10
	// 把变量num存到空接口中
	var i I = num
	fmt.Printf("输出变量i: %v \n", i)
  // 从空接口中取出值，赋值给新的变量 
	var c int = i // (!!! 这里会报错)
	fmt.Printf("输出变量c: %v \n", c)
}
/** 输出
 ./main.go:16:6: cannot use i (type I) as type int in assignment: need type assertion
*/

正确示例:

package main
import "fmt"
// 定义一个空接口
type I interface {
}
func main() {
	// 声明变量num
	num := 10
	// 把变量num存到空接口中
	var i I = num
	fmt.Printf("输出变量i: %v \n", i)
	// 从空接口中取出值，赋值给新的变量
	var c int = i.(int)
	fmt.Printf("输出变量c: %v \n", c)
}
/**
  输出变量i: 10 
  输出变量c: 10 
*/

5. 接口对象转换

5.1 转换语法

// 方式一
instance,ok := 接口对象.(实际类型)
// 方式二
接口对象.(实际类型)

5.2 使用示例

package main
import "fmt"
// 定义一个空接口
type I interface {
}

func main() {
	// 声明变量
	var a I
	// 保存整型
	a = 10
	printType(a)
	printType2(a)
	// 保存字符串
	a = "hello word"
	printType(a)
	printType2(a)
	// 保存数组
	a = [3]float32{1.0, 2.0, 3.0}
	printType(a)
	printType2(a)
	// 保存切片
	a = []string{"您", "好"}
	printType(a)
	printType2(a)
	// 保存Map
	a = map[string]string{
		"张三": "男",
		"小丽": "女",
	}
	printType(a)
	printType2(a)
	// 保存结构体
	a = people{"刘山", 32}
	printType(a)
	printType2(a)
}
// 定义结构体
type people struct {
	name string
	age  int
}

// 方式一
func printType(i I) {
	if t, ok := i.(int); ok {
		echo(t)
	} else if t, ok := i.(string); ok {
		echo(t)
	} else if t, ok := i.(map[string]string); ok {
		echo(t)
	} else if t, ok := i.([]int); ok {
		echo(t)
	} else if t, ok := i.([3]string); ok {
		echo(t)
	} else if t, ok := i.(people); ok {
		echo(t)
	}
}

// 方式二
func printType2(i I) {
	switch i.(type) {
	case int:
		echo2(i)
	case string:
		echo2(i)
	case map[string]string:
		echo2(i)
	case []int:
		echo2(i)
	case [3]string:
		echo2(i)
	case people:
		echo2(i)
	}
}
func echo(i interface{}) {
	fmt.Printf("方式一 ---> 变量i类型: %T 值: %v \n", i, i)
}
func echo2(i interface{}) {
	fmt.Printf("方式二 ---> 变量i类型: %T 值: %v \n", i, i)
}
/**输出
方式一 ---> 变量i类型: int 值: 10 
方式二 ---> 变量i类型: int 值: 10 
方式一 ---> 变量i类型: string 值: hello word 
方式二 ---> 变量i类型: string 值: hello word 
方式一 ---> 变量i类型: map[string]string 值: map[小丽:女 张三:男] 
方式二 ---> 变量i类型: map[string]string 值: map[小丽:女 张三:男] 
方式一 ---> 变量i类型: main.people 值: {刘山 32} 
方式二 ---> 变量i类型: main.people 值: {刘山 32} 
*/