接口就是一系列方法的集合（规范行为）
在面向对象的领域里，接口一般这样定义：接口定义一个对象的行为，规范子类对象的行为。
在 Go 语言中的接口是非侵入式接口（接口没了，不影响代码），侵入式接口（接口没了，子类报错）
Go 也是鸭子类型，比如我现在有个鸭子类，内有 speak 方法和 run 方法，子类只要实现了 speak 和 run，我就认为子类是鸭子，我只要子类中有这两个方法你就是鸭子，有这两个方法你就是鸭子，他是从下往上推导只要有你这里面的东西，那就是算是继承了你这个接口
1、接口的用途
接口是一个类型
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
|
// 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 ，属性，自有方法也有了。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
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 语句所指定的类型进行比较。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
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、空接口
没有任何方法，所有数据类型都实现了空接口
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
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、匿名空接口
没有名字的空接口，一般用在形参上
|
1
2
3
4
5
6
7
8
9
10
11
|
func main() { var duck Duck = WhiteDuck{"小白", 15, "男"} test(10) test("XiaoYang") test(duck)}// 这叫匿名空接口，所有数据类型都可以往里面传，如果想用原来的结构体还需要类型选择回来才能用func test(b interface{}) { fmt.Println(b)} |
6、实现多个接口
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
|
// 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、接口嵌套
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
|
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、接口零值
|
1
2
3
4
5
6
7
|
func main() { var a Animal // nil 就是说明它是一个引用类型 // 其内部表示就已经告诉了我们，它里面就存两个值，一个是它的类型，一个是指向具体值的指针 fmt.Println(a) // 输出：<nil>} |
9、make和new的区别
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
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) // 输出：&[]} |
总结
本篇文章就到这里了，希望能够给你带来帮助，也希望您能够多多关注服务器之家的更多内容！
原文链接：https://www.cnblogs.com/XiaoYang-sir/p/15388749.html
