服务器之家

服务器之家 > 正文

Go语言的接口详解

时间:2021-11-21 13:33     来源/作者:Mr-Yang`

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

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

在 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

标签:

相关文章

热门资讯

yue是什么意思 网络流行语yue了是什么梗
yue是什么意思 网络流行语yue了是什么梗 2020-10-11
背刺什么意思 网络词语背刺是什么梗
背刺什么意思 网络词语背刺是什么梗 2020-05-22
2020微信伤感网名听哭了 让对方看到心疼的伤感网名大全
2020微信伤感网名听哭了 让对方看到心疼的伤感网名大全 2019-12-26
2021年耽改剧名单 2021要播出的59部耽改剧列表
2021年耽改剧名单 2021要播出的59部耽改剧列表 2021-03-05
苹果12mini价格表官网报价 iPhone12mini全版本价格汇总
苹果12mini价格表官网报价 iPhone12mini全版本价格汇总 2020-11-13
返回顶部