【Go】面向对象

阅读：评论：0

【Go】面向对象

文章目录

一、匿名字段
- 1. 什么是匿名字段
- 2. 同名字段的情况
- 3. 所有的内置类型和自定义类型都可以作为匿名字段去使用
- 4. 指针类型匿名字段
- 5. 匿名字段与面向对象
二、接口
- 1. 接口是一种类型
- 2. 为什么要使用接口
- 3. 接口的定义
- 4. 实现接口的条件
- 5. 接口类型变量
- 6. 值接收者和指针接收者实现接口的区别
- - （1）值接收者实现接口
  - （2）指针接收者实现接口
- 7. 类型与接口的关系
- - （1）一个类型实现多个接口
  - （2）多个类型实现同一接口
  - （3）接口嵌套
- 8. 空接口
- - （1）空接口的定义
  - （2）空接口的应用
- 9. 什么时候需要写接口？
三、参考链接

一、匿名字段

1. 什么是匿名字段

go 支持 只提供类型而不写字段名 的方式，也就是 匿名字段 ，也称为嵌入字段。

package mainimport "fmt"//go支持只提供类型而不写字段名的方式，也就是匿名字段，也称为嵌入字段//人-结构体
type Person struct {name stringsex  stringage  int
}type Student struct {Personid   intaddr string
}func main() {// 初始化s1 := Student{Person{"5lmh", "man", 20}, 1, "bj"}fmt.Println(s1)s2 := Student{Person: Person{"5lmh", "man", 20}}fmt.Println(s2)s3 := Student{Person: Person{name: "5lmh"}}fmt.Println(s3)
}

输出结果：

{{5lmh man 20} 1 bj}
{{5lmh man 20} 0 }
{{5lmh  0} 0 }

2. 同名字段的情况

package mainimport "fmt"//人
type Person struct {name stringsex  stringage  int
}type Student struct {Personid   intaddr string//同名字段name string
}func main() {var s Student// 给自己字段赋值了s.name = "5lmh"fmt.Println(s)// 若给父类同名字段赋值，如下s.Person.name = "枯藤"fmt.Println(s)
}

输出结果：

{{  0} 0  5lmh}
{{枯藤  0} 0  5lmh}

3. 所有的内置类型和自定义类型都可以作为匿名字段去使用

package mainimport "fmt"//人
type Person struct {name stringsex  stringage  int
}// 自定义类型
type mystr string// 学生
type Student struct {Personintmystr
}func main() {s1 := Student{Person{"5lmh", "man", 18}, 1, "bj"}fmt.Println(s1)
}

输出结果：

{{5lmh man 18} 1 bj}

4. 指针类型匿名字段

package mainimport "fmt"//人
type Person struct {name stringsex  stringage  int
}// 学生
type Student struct {*Personid   intaddr string
}func main() {s1 := Student{&Person{"5lmh", "man", 18}, 1, "bj"}fmt.Println(s1)fmt.Println(s1.name)fmt.Println(s1.Person.name)
}

输出结果：

{0xc0000c0450 1 bj}
5lmh
5lmh

5. 匿名字段与面向对象

结构体的匿名字段如果是结构体类型，那么该匿名字段就像是一个对父结构体有继承权的子结构体。

通过匿名字段，可 获得和继承类似的复用能力 。依据编译器查找次序，只需在外层定义同名方法，就可以实现 “override”。详细讲解请参考我的另一篇文章：【Go】Go语言中的方法

二、接口

接口（interface）定义了一个对象的行为规范，只定义规范 不实现，由具体的对象来实现规范的细节。

1. 接口是一种类型

在Go语言中接口（interface）是一种类型，一种抽象的类型。

interface 是一组 method 的集合，是 duck-type programming 的一种体现。（duck-type：“当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就可以被称为鸭子”。在鸭子类型中，关注点在于对象的行为，能作什么；而不是关注对象所属的类型。）接口做的事情就像是定义一个协议（规则），只要一台机器有洗衣服和甩干的功能，我就称它为洗衣机。不关心属性（数据），只关心行为（方法）。

为了保护你的Go语言职业生涯，请牢记接口（interface）是一种类型。

2. 为什么要使用接口

实例：

package mainimport "fmt"type Cat struct{}func (c Cat) Say() string { return "喵喵喵" }type Dog struct{}func (d Dog) Say() string { return "汪汪汪" }func main() {c := Cat{}fmt.Println("猫:", c.Say())d := Dog{}fmt.Println("狗:", d.Say())
}

输出结果：

猫: 喵喵喵
狗: 汪汪汪

上面的代码中定义了猫和狗，然后它们都会叫，你会发现 main 函数中明显有重复的代码，如果我们后续再加上猪、青蛙等动物的话，我们的代码还会一直重复下去。那我们能不能把它们当成“能叫的动物”来处理呢？

像类似的例子在我们编程过程中会经常遇到：

比如一个网上商城可能使用支付宝、微信、银联等方式去在线支付，我们能不能把它们当成“支付方式”来处理呢？

比如三角形，四边形，圆形都能计算周长和面积，我们能不能把它们当成“图形”来处理呢？

比如销售、行政、程序员都能计算月薪，我们能不能把他们当成“员工”来处理呢？

Go语言中为了解决类似上面的问题，就设计了接口这个概念。接口区别于我们之前所有的具体类型，接口是一种抽象的类型。当你看到一个接口类型的值时，你不知道它是什么，唯一知道的是通过它的方法能做什么。

3. 接口的定义

Go语言提倡 面向接口 编程。

接口是一个或多个方法的签名的集合。
任何类型的方法集中只要拥有该接口对应的 全部方法 签名，就表示它 “实现” 了该接口，无须在该类型上显式声明实现了哪个接口。这称为Structural Typing。
所谓对应方法，是指有相同名称、参数列表 (不包括参数名) 以及返回值。
当然，该类型还可以有其他方法。

注意：

接口只有 方法声明 ，没有实现，没有数据字段。
接口可以匿名嵌入其他接口，或嵌入到结构中。
对象赋值给接口时，会发生拷贝，而接口内部存储的是指向这个复制品的指针，既无法修改复制品的状态，也无法获取指针。
只有当接口存储的类型和对象都为nil时，接口才等于nil。
接口调用不会做 receiver 的自动转换。
接口同样支持匿名字段方法。
接口也可实现类似OOP中的多态。
空接口可以作为任何类型数据的容器。
一个类型可实现多个接口。
接口命名习惯以 er 结尾。

接口定义的语法：

每个接口由数个方法组成，接口的定义格式如下：

 type 接口类型名 interface{方法名1( 参数列表1 ) 返回值列表1方法名2( 参数列表2 ) 返回值列表2…}

其中：

接口名：使用 type 将接口定义为自定义的类型名。Go语言的接口在命名时，一般会在单词后面添加er，如有写操作的接口叫Writer，有字符串功能的接口叫Stringer等。接口名最好要能突出该接口的类型含义。
方法名：当方法名首字母是大写且这个接口类型名首字母也是大写时，这个方法可以被接口所在的包（package）之外的代码访问。
参数列表、返回值列表：参数列表和返回值列表中的参数变量名可以省略。

举个例子：

type writer interface{Write([]byte) error
}

当你看到这个接口类型的值时，你不知道它是什么，唯一知道的就是可以通过它的Write方法来做一些事情。

4. 实现接口的条件

一个对象 只要实现了接口中的 全部方法 ，那么就实现了这个接口。换句话说，接口就是一个需要实现的方法列表。

我们来定义一个 Sayer 接口：

// Sayer 接口
type Sayer interface {Say()
}

定义dog和cat两个结构体：

type Cat struct{}
type Dog struct {}

因为Sayer接口里只有一个 say 方法，所以我们只需要给 dog 和 cat 分别实现 say 方法就可以实现 Sayer 接口了。

// cat实现了Sayer接口
func (c Cat) Say() {fmt.Println("喵喵喵")
}// dog实现了Sayer接口
func (d Dog) Say() {fmt.Println("汪汪汪")
}

接口的实现就是这么简单，只要实现了接口中的所有方法，就实现了这个接口。

5. 接口类型变量

那实现了接口有什么用呢？

Important：接口类型变量能够存储所有实现了该接口的实例。

例如上面的示例中，Sayer 类型的变量能够存储 dog 和 cat 类型的变量。

func main() {var x Sayer // 声明一个Sayer类型的变量xa := cat{}  // 实例化一个catb := dog{}  // 实例化一个dogx = a       // 可以把cat实例直接赋值给xx.say()     // 喵喵喵x = b       // 可以把dog实例直接赋值给xx.say()     // 汪汪汪
}

可以将实现了接口的结构体理解为该接口类型的一个实例。

完整代码：

package mainimport "fmt"//“说话者”接口，包含一个声明的方法Say()
type Sayer interface {Say()
}//定义Cat结构体并在其上实现方法Say()，那么Cat实现了接口Sayer
type Cat struct{}func (c Cat) Say() {fmt.Println("喵喵喵")
}//定义Dog结构体并在其上实现方法Say()，那么Dog实现了接口Sayer
type Dog struct{}func (d Dog) Say() {fmt.Println("汪汪汪")
}func main() {var x Sayera := Cat{} // 实例化一个Catb := Dog{} // 实例化一个Dogx = a   // 可以把Cat实例直接赋值给xx.Say() // 喵喵喵x = b   // 可以把Dog实例直接赋值给xx.Say() // 汪汪汪}

输出结果：

喵喵喵
汪汪汪

或者：

package mainimport "fmt"//“说话者”接口，包含一个声明的方法Say()
type Sayer interface {Say()
}//定义Cat结构体并在其上实现方法Say()，那么Cat实现了接口Sayer
type Cat struct{}func (c Cat) Say() {fmt.Println("喵喵喵")
}//定义Dog结构体并在其上实现方法Say()，那么Dog实现了接口Sayer
type Dog struct{}func (d Dog) Say() {fmt.Println("汪汪汪")
}func main() {var x Sayerx = Cat{}   //接口类型变量X可以存储所有实现了该接口的类型的变量x.Say()x = Dog{}x.Say()}

输出结果：

喵喵喵
汪汪汪

6. 值接收者和指针接收者实现接口的区别

使用值接收者实现接口和使用指针接收者实现接口有什么区别呢？接下来我们通过一个例子看一下其中的区别。

我们有一个Mover接口和一个dog结构体。

type Mover interface {move()
}type dog struct {}

（1）值接收者实现接口

值接收者是：在结构体 dog 上实现接口中的方法 move() 时，接收者是值类型的（不是指针类型）。

func (d dog) move() {  //dog类型实现了接口Moverfmt.Println("狗会动")
}

此时，dog 类型 实现了接口 Mover，接口类型 Mover 的变量就可以接收 dog 类型的变量了，同时，接口类型 Mover 的变量还可以接收 ^*dog类型的变量：

func main() {var x Movervar wangcai = dog{} // 旺财是dog类型x = wangcai         // x可以接收dog类型var fugui = &dog{}  // 富贵是*dog类型x = fugui           // x可以接收*dog类型x.move()
}

完整代码：

package mainimport "fmt"type Mover interface {move()
}type dog struct{}func (d dog) move() {   //dog类型实现了接口Moverfmt.Println("狗会动")
}func main() {var x Movervar wangcai = dog{} // 旺财是dog类型x = wangcai         // x可以接收dog类型x.move()var fugui = &dog{} // 富贵是*dog类型x = fugui          // x可以接收*dog类型x.move()
}

输出结果：

狗会动
狗会动

从上面的代码中我们可以发现，使用值接收者实现接口之后，不管是 dog 结构体还是结构体指针 ^*dog 类型的变量都可以赋值给该接口变量。
因为Go语言中有 对指针类型变量求值 的语法糖，dog 指针 fugui 内部会自动求值 *fugui 。

（2）指针接收者实现接口

同样的代码我们再来测试一下使用指针接收者有什么区别：

func (d *dog) move() {   //*dog类型实现了接口Moverfmt.Println("狗会动")
}
func main() {var x Movervar wangcai = dog{} // 旺财是dog类型x = wangcai         // x不可以接收dog类型，会报错cannot use wangcai (type dog) as type Mover in assignmentvar fugui = &dog{}  // 富贵是*dog类型x = fugui           // x可以接收*dog类型
}

完整代码：

package mainimport "fmt"type Mover interface {move()
}type dog struct{}func (d *dog) move() {    //*dog类型实现了接口Moverfmt.Println("狗会动")
}func main() {var x Mover//var wangcai = dog{} // 旺财是dog类型//x = wangcai         // x不可以接收dog类型var fugui = &dog{} // 富贵是*dog类型x = fugui          // x可以接收*dog类型x.move()
}

输出结果：

狗会动

此时 ^*dog类型 实现了 Mover 接口，所以不能给 x 传入 dog 类型的 wangcai，此时 x 只能存储 *dog 类型的值。

下面的代码是一个比较好的面试题：请问下面的代码是否能通过编译？

package mainimport "fmt"type People interface {Speak(string) string
}type Student struct{}func (stu *Student) Speak(think string) (talk string) {if think == "sb" {talk = "你是个大帅比"} else {talk = "您好"}return
}func main() {var peo People = Student{}think := "bitch"fmt.Println(peo.Speak(think)) //peo是Student类型的，而实现接口方法Speak的是*Student类型，所以会出错
}

报错：

# hello
.:21:6: cannot use Student{} (type Student) as type People in assignment:Student does not implement People (Speak method has pointer receiver)

这样改就好了：

package mainimport "fmt"type People interface {Speak(string) string
}type Student struct{}func (stu *Student) Speak(think string) (talk string) {if think == "sb" {talk = "你是个大帅比"} else {talk = "您好"}return
}func main() {var peo People = &Student{} //改成*Stduent类型think := "bitch"fmt.Println(peo.Speak(think))
}

输出结果：

您好

7. 类型与接口的关系

（1）一个类型实现多个接口

一个类型可以同时实现多个接口，而接口间彼此独立，不知道对方的实现。例如，狗可以叫，也可以动。我们就分别定义 Sayer 接口和 Mover 接口，如下：

// Sayer 接口
type Sayer interface {say()
}// Mover 接口
type Mover interface {move()
}

类型 dog 既可以实现 Sayer 接口，也可以实现 Mover 接口：

type dog struct {name string
}// 实现Sayer接口
func (d dog) say() {fmt.Printf("%s会叫汪汪汪n", d.name)
}// 实现Mover接口
func (d dog) move() {fmt.Printf("%s会动n", d.name)
}

完整代码：

package mainimport "fmt"// Sayer 接口
type Sayer interface {say()
}// Mover 接口
type Mover interface {move()
}type dog struct {name string
}// 实现Sayer接口
func (d dog) say() {fmt.Printf("%s会叫汪汪汪n", d.name)
}// 实现Mover接口
func (d dog) move() {fmt.Printf("%s会动n", d.name)
}func main() {var x Sayervar y Movervar a = dog{name: "旺财"}x = ay = ax.say()y.move()
}

输出结果：

旺财会叫汪汪汪
旺财会动

（2）多个类型实现同一接口

Go语言中不同的类型还可以实现同一接口。

首先我们定义一个 Mover 接口，它要求必须有一个 move 方法。

// Mover 接口
type Mover interface {move()
}

例如狗可以动，汽车也可以动，可以使用如下代码实现这个关系：

type dog struct {name string
}type car struct {brand string
}// dog类型实现Mover接口
func (d dog) move() {fmt.Printf("%s会跑n", d.name)
}// car类型实现Mover接口
func (c car) move() {fmt.Printf("%s速度70迈n", c.brand)
}

这个时候我们在代码中就可以把狗和汽车当成一个会动的物体来处理了，不再需要关注它们具体是什么，只需要调用它们的 move 方法就可以了。

func main() {var x Movervar a = dog{name: "旺财"}var b = car{brand: "保时捷"}x = ax.move()x = bx.move()
}

完整代码：

package mainimport "fmt"// Mover 接口
type Mover interface {move()
}type dog struct {name string
}type car struct {brand string
}// dog类型实现Mover接口
func (d dog) move() {fmt.Printf("%s会跑n", d.name)
}// car类型实现Mover接口
func (c car) move() {fmt.Printf("%s速度70迈n", c.brand)
}func main() {var x Movervar a = dog{name: "旺财"}var b = car{brand: "保时捷"}x = ax.move()x = bx.move()
}

输出结果：

旺财会跑
保时捷速度70迈

并且一个接口的方法，不一定需要由一个类型完全实现。

可以通过在类型中嵌入其他类型或者结构体来 “继承” 其对接口方法的实现，从而只实现剩下的方法，就能完全实现接口。

下例中，dryer 结构体实现了接口的 dry() 方法；haier 结构体由于内嵌了 dryer 结构体，所以 “继承” 了它对 dry() 方法的实现，然后 haier 自己实现了 wash() 方法。这样，haier 结构体把接口的两个方法都实现了，就实现了接口。

而 dryer 结构体由于只实现了dry() 方法，所以没能实现接口。所以如果你把var x WashingMachine = haier{}改成var x WashingMachine = dryer{}就会报错：cannot use dryer{} (type dryer) as type WashingMachine in assignment: dryer does not implement WashingMachine (missing wash method)（提示你 dryer 结构体缺失了 wash 方法的实现）

package mainimport "fmt"// WashingMachine 洗衣机
type WashingMachine interface {wash()dry()
}type dryer struct{} // 甩干器
func (d dryer) dry() { // 实现WashingMachine接口的dry()方法fmt.Println("甩一甩")
}type haier struct { // 海尔洗衣机dryer // 匿名字段，嵌入甩干器
}
func (h haier) wash() { // 实现WashingMachine接口的wash()方法fmt.Println("洗刷刷")
}func main() {var x WashingMachine = haier{}x.wash()x.dry()
}

输出结果：

洗刷刷
甩一甩

（3）接口嵌套

接口与接口间可以通过嵌套创造出新的接口。

// Sayer 接口
type Sayer interface {say()
}// Mover 接口
type Mover interface {move()
}// 接口嵌套
type animal interface {SayerMover
}

嵌套得到的接口的使用与普通接口一样，这里我们让 cat 实现 animal 接口：

animal 接口内嵌了Sayer接口和Mover接口，那么 cat 实现了 Sayer 和 Mover 接口，就是实现了 animal 接口。

type cat struct {name string
}func (c cat) say() {  //cat实现了Sayer接口fmt.Println("喵喵喵")
}func (c cat) move() { //cat实现了Mover接口fmt.Println("猫会动")
}

完整代码：

package mainimport "fmt"// Sayer 接口
type Sayer interface {say()
}// Mover 接口
type Mover interface {move()
}// 接口嵌套
type animal interface {SayerMover
}type cat struct {name string
}func (c cat) say() { //cat实现了Sayer接口fmt.Println("喵喵喵")
}func (c cat) move() { //cat实现了Mover接口fmt.Println("猫会动")
}func main() {var x animalx = cat{name: "花花"}x.move()x.say()
}

输出结果：

猫会动
喵喵喵

8. 空接口

（1）空接口的定义

空接口是指 没有定义任何方法 的接口。因此任何类型都实现了空接口。

Important：空接口类型的变量可以存储任意类型的变量。

也就是说，我们创建一个空接口变量，它可以被赋予任何值。

package mainimport "fmt"func main() {// 定义一个空接口xvar x interface{}s := "pprof" //字符串变量x = sfmt.Printf("type:%T value:%vn", x, x)i := 100        //整型变量x = ifmt.Printf("type:%T value:%vn", x, x)b := true       //布尔变量x = bfmt.Printf("type:%T value:%vn", x, x)
}

输出结果：

type:string value:pprof
type:int value:100
type:bool value:true

（2）空接口的应用

1> 空接口作为函数的参数。

使用空接口实现 可以接收任意类型 的函数参数。

// 空接口作为函数参数
func show(a interface{}) {fmt.Printf("type:%T value:%vn", a, a)
}

2> 空接口作为map的值。

使用空接口实现 可以保存任意值 的字典。

// 空接口作为map值
var studentInfo = make(map[string]interface{})
studentInfo["name"] = "李白"
studentInfo["age"] = 18
studentInfo["married"] = false
fmt.Println(studentInfo)

3> 类型断言。

空接口可以存储任意类型的值，那我们如何获取其存储的具体数据呢？

接口值：一个接口的值（简称接口值）是由一个具体类型和具体类型的值两部分组成的。这两部分分别称为接口的 动态类型 和 动态值 。

我们来看一个具体的例子：

var w io.Writer
w = os.Stdout
w = new(bytes.Buffer)
w = nil

请看下图分解：

想要 判断空接口中的值，这个时候就可以使用 类型断言 ，其语法格式：

x.(T)

其中：

x：一个类型为interface{}的变量
T：断言 x 可能是的一个具体类型

该语法返回两个参数，第一个参数是 x 转化为 T 类型后的变量，第二个值是一个布尔值，若为 true 则表示断言成功，为 false 则表示断言失败。

举个例子：

func main() {var x interface{}x = "pprof"v, ok := x.(string)  //判断 x 是字符串类型if ok {   //true fmt.Println(v)} else {  //false fmt.Println("类型断言失败")}
}

输出结果：

pprof

上面的示例中如果要断言多次就需要写多个 if 判断，这个时候我们可以使用 switch 语句来实现：

package mainimport "fmt"func justifyType(x interface{}) {switch v := x.(type) {case string:fmt.Printf("x is a string，value is %vn", v)case int:fmt.Printf("x is a int is %vn", v)case bool:fmt.Printf("x is a bool is %vn", v)default:fmt.Println("unsupport type！")}
}func main() {var s interface{}var a = trues = ajustifyType(s)
}

输出结果：