• 100天精通Golang（基础入门篇）——第20天：Golang 接口 深度解析☞从基础到高级

    在这里插入图片描述

    🌷🍁 博主猫头虎🐅🐾 带您进入 Golang 语言的新世界✨✨🍁
    🦄 博客首页——🐅🐾猫头虎的博客🎐
    🐳 《面试题大全专栏》 🦕 文章图文并茂🦖生动形象🐅简单易学！欢迎大家来踩踩~🌺
    🌊 《IDEA开发秘籍专栏》 🐾 学会IDEA常用操作，工作效率翻倍~💐
    🌊 《100天精通Golang(基础入门篇）》 🐅 学会Golang语言，畅游云原生领域，无厂不可去~💐

    🪁🍁 希望本文能给您带来价值🌸如果有任何不足，欢迎批评指正！🐅🐾🍁🐥

    100天精通Golang（基础入门篇）

    100天精通Golang（基础入门篇）——第20天：接口

    摘要

    📝 第二十天来了，继续我们的 “100天精通Golang（基础入门篇）” 旅程！今天的重点是：Golang 接口深度解析☞从基础到高级。本篇将全方位地揭示接口在 Golang 中的重要性，以及如何让你的代码更加模块化、可测试和可维护。🎯

    📝 探究 Golang 的接口机制如何使代码更加模块化、可测试和可维护。本文将从接口的定义、使用，到高级特性进行全面剖析。

    导语

    👋 大家好，我是猫头虎！今天我们将一同进入 Golang 的神秘花园，探寻接口（Interface）的无穷魅力。如果你对如何有效地使用 Golang 的接口机制感到好奇，那么这篇文章一定适合你。🌟

    引言

    🎙 在面向对象编程中，接口是一个非常重要的概念。但在 Golang 中，接口不仅用于描述对象的行为，还有许多高级的用途和特性。这使得 Golang 在类型系统的设计上显得非常独特和灵活。接口可以用于多态、代码解耦、错误处理等多个方面，其强大的功能和灵活性使得它成为 Golang 不可或缺的一部分。🛠

    1.1 什么是接口?

    面向对象世界中的接口的一般定义是“接口定义对象的行为”。它表示让指定对象应该做什么。实现这种行为的方法(实现细节)是针对对象的。

    在Go中，接口是一组方法签名。当类型为接口中的所有方法提供定义时，它被称为实现接口。它与OOP非常相似。接口指定了类型应该具有的方法，类型决定了如何实现这些方法。

    它把所有的具有共性的方法定义在一起，任何其他类型只要实现了这些方法就是实现了这个接口

    接口定义了一组方法，如果某个对象实现了某个接口的所有方法，则此对象就实现了该接口。

    1.2 接口的定义语法

    定义接口

    /* 定义接口 */
type interface_name interface {
   method_name1 [return_type]
   method_name2 [return_type]
   method_name3 [return_type]
   ...
   method_namen [return_type]
}

/* 定义结构体 */
type struct_name struct {
   /* variables */
}

/* 实现接口方法 */
func (struct_name_variable struct_name) method_name1() [return_type] {
   /* 方法实现 */
}
...
func (struct_name_variable struct_name) method_namen() [return_type] {
   /* 方法实现*/
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    示例代码：

    package main

import (
    "fmt"
)

type Phone interface {
    call()
}

type NokiaPhone struct {
}

func (nokiaPhone NokiaPhone) call() {
    fmt.Println("I am Nokia, I can call you!")
}

type IPhone struct {
}

func (iPhone IPhone) call() {
    fmt.Println("I am iPhone, I can call you!")
}

func main() {
    var phone Phone

    phone = new(NokiaPhone)
    phone.call()

    phone = new(IPhone)
    phone.call()

}

    • 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

    运行结果：

    I am Nokia, I can call you!
I am iPhone, I can call you!

    • 1
    • 2
    • interface可以被任意的对象实现
    • 一个对象可以实现任意多个interface
    • 任意的类型都实现了空interface(我们这样定义：interface{})，也就是包含0个method的interface

    1.3 interface值

    package main

import "fmt"

type Human struct {
	name  string
	age   int
	phone string
}
type Student struct {
	Human  //匿名字段
	school string
	loan   float32
}
type Employee struct {
	Human   //匿名字段
	company string
	money   float32
} //Human实现Sayhi方法
func (h Human) SayHi() {
	fmt.Printf("Hi, I am %s you can call me on %s\n", h.name, h.phone)
} //Human实现Sing方法
func (h Human) Sing(lyrics string) {
	fmt.Println("La la la la...", lyrics)
} //Employee重写Human的SayHi方法
func (e Employee) SayHi() {
	fmt.Printf("Hi, I am %s, I work at %s. Call me on %s\n", e.name,
		e.company, e.phone) //Yes you can split into 2 lines here.
}

// Interface Men被Human,Student和Employee实现
// 因为这三个类型都实现了这两个方法
type Men interface {
	SayHi()
	Sing(lyrics string)
}

func main() {
	mike := Student{Human{"Mike", 25, "222-222-XXX"}, "MIT", 0.00}
	paul := Student{Human{"Paul", 26, "111-222-XXX"}, "Harvard", 100}
	sam := Employee{Human{"Sam", 36, "444-222-XXX"}, "Golang Inc.", 1000}
	Tom := Employee{Human{"Sam", 36, "444-222-XXX"}, "Things Ltd.", 5000}
	//定义Men类型的变量i
	var i Men
	//i能存储Student
	i = mike
	fmt.Println("This is Mike, a Student:")
	i.SayHi()
	i.Sing("November rain")
	//i也能存储Employee
	i = Tom
	fmt.Println("This is Tom, an Employee:")
	i.SayHi()
	i.Sing("Born to be wild")
	//定义了slice Men
	fmt.Println("Let's use a slice of Men and see what happens")
	x := make([]Men, 3)
	//T这三个都是不同类型的元素，但是他们实现了interface同一个接口
	x[0], x[1], x[2] = paul, sam, mike
	for _, value := range x {
		value.SayHi()
	}
}

    • 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
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63

    运行结果：

    	This is Mike, a Student:
	Hi, I am Mike you can call me on 222-222-XXX
	La la la la... November rain
	This is Tom, an Employee:
	Hi, I am Sam, I work at Things Ltd.. Call me on 444-222-XXX
	La la la la... Born to be wild
	Let's use a slice of Men and see what happens
	Hi, I am Paul you can call me on 111-222-XXX
	Hi, I am Sam, I work at Golang Inc.. Call me on 444-222-XXX
	Hi, I am Mike you can call me on 222-222-XXX

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    那么interface里面到底能存什么值呢？如果我们定义了一个interface的变量，那么这个变量里面可以存实现这个interface的任意类型的对象。例如上面例子中，我们定义了一个Men interface类型的变量m，那么m里面可以存Human、Student或者Employee值

    当然，使用指针的方式，也是可以的

    但是，接口对象不能调用实现对象的属性

    interface函数参数

    interface的变量可以持有任意实现该interface类型的对象，这给我们编写函数(包括method)提供了一些额外的思考，我们是不是可以通过定义interface参数，让函数接受各种类型的参数

    嵌入interface

    package main

import "fmt"

type Human interface {
	Len()
}
type Student interface {
	Human
}

type Test struct {
}

func (h *Test) Len() {
	fmt.Println("成功")
}
func main() {
	var s Student
	s = new(Test)
	s.Len()
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    示例代码：

    package test

import (
	"fmt"
)

type Controller struct {
	M int32
}

type Something interface {
	Get()
	Post()
}

func (c *Controller) Get() {
	fmt.Print("GET")
}

func (c *Controller) Post() {
	fmt.Print("POST")
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    package main

import (
	"fmt"
	"test"
)

type T struct {
	test.Controller
}

func (t *T) Get() {
	//new(test.Controller).Get()
	fmt.Print("T")
}
func (t *T) Post() {
	fmt.Print("T")
}
func main() {
	var something test.Something
	something = new(T)
	var t T
	t.M = 1
	//	t.Controller.M = 1
	something.Get()
}

    • 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

    Controller实现了所有的Something接口方法，当结构体T中调用Controller结构体的时候，T就相当于Java中的继承，T继承了Controller，因此，T可以不用重写所有的Something接口中的方法，因为父构造器已经实现了接口。

    如果Controller没有实现Something接口方法，则T要调用Something中方法，就要实现其所有方法。

    如果something = new(test.Controller)则调用的是Controller中的Get方法。

    T可以使用Controller结构体中定义的变量

    1.4 接口的类型

    接口与鸭子类型：

    先直接来看维基百科里的定义：

    If it looks like a duck, swims like a duck, and quacks like a duck, then it probably is a duck.

    翻译过来就是：如果某个东西长得像鸭子，像鸭子一样游泳，像鸭子一样嘎嘎叫，那它就可以被看成是一只鸭子。

    Duck Typing，鸭子类型，是动态编程语言的一种对象推断策略，它更关注对象能如何被使用，而不是对象的类型本身。Go 语言作为一门静态语言，它通过通过接口的方式完美支持鸭子类型。

    而在静态语言如 Java, C++ 中，必须要显示地声明实现了某个接口，之后，才能用在任何需要这个接口的地方。如果你在程序中调用某个数，却传入了一个根本就没有实现另一个的类型，那在编译阶段就不会通过。这也是静态语言比动态语言更安全的原因。

    动态语言和静态语言的差别在此就有所体现。静态语言在编译期间就能发现类型不匹配的错误，不像动态语言，必须要运行到那一行代码才会报错。当然，静态语言要求程序员在编码阶段就要按照规定来编写程序，为每个变量规定数据类型，这在某种程度上，加大了工作量，也加长了代码量。动态语言则没有这些要求，可以让人更专注在业务上，代码也更短，写起来更快，这一点，写 python 的同学比较清楚。

    Go 语言作为一门现代静态语言，是有后发优势的。它引入了动态语言的便利，同时又会进行静态语言的类型检查，写起来是非常 Happy 的。Go 采用了折中的做法：不要求类型显示地声明实现了某个接口，只要实现了相关的方法即可，编译器就能检测到。

    总结一下，鸭子类型是一种动态语言的风格，在这种风格中，一个对象有效的语义，不是由继承自特定的类或实现特定的接口，而是由它"当前方法和属性的集合"决定。Go 作为一种静态语言，通过接口实现了鸭子类型，实际上是 Go 的编译器在其中作了隐匿的转换工作。

    Go语言的多态性：

    Go中的多态性是在接口的帮助下实现的。正如我们已经讨论过的，接口可以在Go中隐式地实现。如果类型为接口中声明的所有方法提供了定义，则实现一个接口。让我们看看在接口的帮助下如何实现多态。

    任何定义接口所有方法的类型都被称为隐式地实现该接口。

    类型接口的变量可以保存实现接口的任何值。接口的这个属性用于实现Go中的多态性。

    1.5 接口断言

    前面说过，因为空接口 interface{}没有定义任何函数，因此 Go 中所有类型都实现了空接口。当一个函数的形参是interface{}，那么在函数中，需要对形参进行断言，从而得到它的真实类型。

    语法格式：

    // 安全类型断言

<目标类型的值>，<布尔参数> := <表达式>.( 目标类型 )

//非安全类型断言

<目标类型的值> := <表达式>.( 目标类型 )


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    示例代码：

    package main

import "fmt"

func main() {

   var i1 interface{} = new (Student)
   s := i1.(Student) //不安全，如果断言失败，会直接panic

   fmt.Println(s)


	var i2 interface{} = new(Student)
	s, ok := i2.(Student) //安全，断言失败，也不会panic，只是ok的值为false
	if ok {
		fmt.Println(s)
	}
}

type Student struct {

}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23

    断言其实还有另一种形式，就是用在利用 switch语句判断接口的类型。每一个case会被顺序地考虑。当命中一个case 时，就会执行 case 中的语句，因此 case 语句的顺序是很重要的，因为很有可能会有多个 case匹配的情况。

    示例代码：

    switch ins:=s.(type) {
	case Triangle:
		fmt.Println("三角形。。。",ins.a,ins.b,ins.c)
	case Circle:
		fmt.Println("圆形。。。。",ins.radius)
	case int:
		fmt.Println("整型数据。。")
	}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    1.6 接口的组合

    在 Go 语言中，一个接口可以由多个小接口组合而成。这样的组合方式提供了一种“继承”的感觉，使得接口更加模块化。

    type Reader interface {
    Read(p []byte) (n int, err error)
}

type Writer interface {
    Write(p []byte) (n int, err error)
}

type ReadWriter interface {
    Reader
    Writer
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    在这个例子中，ReadWriter 接口组合了 Reader 和 Writer 接口，一个实现了 ReadWriter 接口的类必须实现所有 Reader 和 Writer 接口中定义的方法。

    1.7 接口的零值和nil

    在 Go 中，接口内部有两个组件，一个是具体的类型，另一个是该类型的值。当我们定义一个接口变量时，这两个组件都会初始化为 nil。

    var a interface{}
fmt.Printf("%v, %T\n", a, a) // "nil, nil"

    • 1
    • 2

    当一个接口变量的类型和值都为 nil 时，我们称该变量为 nil 接口变量。

    1.8 接口和指针

    指针类型和它所指向的值类型是两个不同的类型，因此，如果一个接口类型的方法集合包含使用值接收者定义的方法，那么这个接口可以存储这个指针类型的值。

    type Describer interface {
    Describe()
}

type Person struct {
    name string
}

func (p Person) Describe() {
    fmt.Println("I am a person.")
}

func main() {
    var d1 Describer
    p1 := Person{"Sam"}
    d1 = &p1
    d1.Describe()
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    1.9 接口嵌套和方法冲突

    接口也可以嵌套接口，但要注意方法不要冲突。

    type ReadCloser interface {
    Reader
    Closer
}
type Closer interface {
    Close() error
    //Read() // 这里如果定义Read方法，将与Reader接口冲突
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    1.10 接口的实用技巧

    1. 类型查询: 除了类型断言，你还可以使用 , ok 语法来安全地查询值的类型。

      if val, ok := myVar.(MyType); ok {
    // ...
}

      • 1
      • 2
      • 3

    2. 使用接口收集不同类型的值: 你可以创建接受接口类型参数的函数或方法，以处理不同类型的值。

    3. 使用接口实现模板模式: 通过定义一个接口来封装算法的变化，然后通过具体的类型来实现算法的可替换部分。

    1.11 错误处理与接口

    Go 语言中的错误处理也是基于接口的。标准库中有一个 error 接口用于处理错误：

    type error interface {
    Error() string
}

    • 1
    • 2
    • 3

    自定义错误通常会实现这个接口，提供更多的上下文信息和错误处理能力。

    1.12 测试与接口

    在 Go 中进行单元测试时，接口非常有用。你可以创建模拟对象来代替真实的依赖，这些模拟对象实现了同样的接口。

    这样的话，你可以在测试环境下替换这些依赖，使得单元测试更加容易编写和维护。

    总结

    🔍 通过本文，你应该对 Golang 的接口有了全面且深入的理解。无论是基础的类型实现，还是高级的接口组合和多态性，接口都能让我们的代码更加简洁和高效。掌握接口不仅可以让你更加自如地使用 Golang，也会极大地提升你的编程水平。记住，掌握接口就是走向 Golang 高手之路的关键一步。🔑

    接口在 Go 中是一种非常强大和灵活的机制，用于解耦和组织代码。它们提供了一种方式来规范对象行为，允许我们编写可复用和可测试的代码。了解和掌握接口是成为 Go 语言高手的关键之一。

    参考资料

    📚

    1. Go Programming Language Specification
    2. Effective Go
    3. Go Blog: Interfaces in Go
    4. Go by Example: Interfaces

    希望大家喜欢这篇文章！如果你有任何问题或想要进一步探讨，随时在下方留言。👇 不要忘了点赞和分享！👍🚀

    在这里插入图片描述

    结语

    通过今天的学习，您已经踏上了Golang的学习之旅。在未来的日子里，您将探索Golang的各个方面，从基础概念到高级技巧，从实际应用到性能优化。
    学习一门编程语言是一个持续的过程，每一天都是您向Golang的精通迈进的重要一步。我鼓励您坚持每天学习，保持热情和好奇心，解决挑战并享受成功的喜悦。

    在您的学习旅程中，不要忘记参与社区和与其他Golang开发者交流。分享您的见解和经验，向他人学习，并在开源项目或实际应用中展示您的技能。

    如果您在学习过程中遇到困难或有任何问题，不要犹豫向社区和专家寻求帮助。持续学习，勇敢探索，您将在Golang领域取得令人瞩目的成就。

    最后，感谢您的阅读和支持！祝愿您在未来的每一天中都能够成为一名精通Golang的开发者！

    期待听到您在学习过程中的进展和成就。如果您需要进一步的帮助，请随时告诉我。祝您在学习Golang的旅程中取得巨大成功！

    点击下方名片，加入IT技术核心学习团队。一起探索科技的未来，共同成长。

    如果您在学习过程中有任何疑惑，请点击下方名片，带您一对一快速入门 Go语言 的世界 ~

  • 相关阅读:
    体系结构29_多处理机的互联网络
    PositiveSSL的泛域名SSL证书
    Linux网络设置
    蓝桥杯备考随手记: 常用的三种排序算法（冒泡排序、插入排序、选择排序）
    mysql数据库备份与回滚
    算法通关村之字符串（实战训练）经典问题：转换小写字母、字符串反转、K个一组反转、仅反转字母
    Java-集合框架
    《微积分的力量》读书摘记
    【数据库数据恢复】SQL SERVER数据库MDF (NDF)或LDF损坏怎么恢复数据？
    基于 selenium 实现网站图片采集
  • 原文地址：https://blog.csdn.net/qq_44866828/article/details/132607976