投稿
  1. 极客之音首页
  2. 后端笔记

【Go】面向对象 – 匿名字段、接口

seven_ • • 后端笔记 • 阅读 69

导读：本篇文章讲解 【Go】面向对象 – 匿名字段、接口，希望对大家有帮助，欢迎收藏，转发！站点地址：www.bmabk.com

文章目录

一、匿名字段

1. 什么是匿名字段

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

package main

import "fmt"

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

//人-结构体
type Person struct {
	name string
	sex  string
	age  int
}

type Student struct {
	Person
	id   int
	addr 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 main

import "fmt"

//人
type Person struct {
	name string
	sex  string
	age  int
}

type Student struct {
	Person
	id   int
	addr 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 main

import "fmt"

//人
type Person struct {
	name string
	sex  string
	age  int
}

// 自定义类型
type mystr string

// 学生
type Student struct {
	Person
	int
	mystr
}

func main() {
	s1 := Student{Person{"5lmh", "man", 18}, 1, "bj"}
	fmt.Println(s1)
}

输出结果：

{{5lmh man 18} 1 bj}

4. 指针类型匿名字段

package main

import "fmt"

//人
type Person struct {
	name string
	sex  string
	age  int
}

// 学生
type Student struct {
	*Person
	id   int
	addr 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 main

import "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语言提倡 面向接口 编程。

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

注意：

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

接口定义的语法：

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

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

其中：

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

举个例子：

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类型的变量x
    a := cat{}  // 实例化一个cat
    b := dog{}  // 实例化一个dog
    x = a       // 可以把cat实例直接赋值给x
    x.say()     // 喵喵喵
    x = b       // 可以把dog实例直接赋值给x
    x.say()     // 汪汪汪
}

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

完整代码：

package main

import "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 Sayer
	a := Cat{} // 实例化一个Cat
	b := Dog{} // 实例化一个Dog

	x = a   // 可以把Cat实例直接赋值给x
	x.Say() // 喵喵喵
	x = b   // 可以把Dog实例直接赋值给x
	x.Say() // 汪汪汪

}

输出结果：

喵喵喵
汪汪汪

或者：

package main

import "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 Sayer
	x = 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类型实现了接口Mover
    fmt.Println("狗会动")
}

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

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

完整代码：

package main

import "fmt"

type Mover interface {
	move()
}

type dog struct{}

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

func main() {
	var x Mover
	var 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类型实现了接口Mover
    fmt.Println("狗会动")
}
func main() {
    var x Mover
    var wangcai = dog{} // 旺财是dog类型
    x = wangcai         // x不可以接收dog类型，会报错cannot use wangcai (type dog) as type Mover in assignment
    var fugui = &dog{}  // 富贵是*dog类型
    x = fugui           // x可以接收*dog类型
}

完整代码：

package main

import "fmt"

type Mover interface {
	move()
}

type dog struct{}

func (d *dog) move() {    //*dog类型实现了接口Mover
	fmt.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 main

import "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
.\main.go:21:6: cannot use Student{} (type Student) as type People in assignment:
	Student does not implement People (Speak method has pointer receiver)

这样改就好了：

package main

import "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 main

import "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 Sayer
	var y Mover

	var a = dog{name: "旺财"}
	x = a
	y = a
	x.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 Mover
    var a = dog{name: "旺财"}
    var b = car{brand: "保时捷"}
    x = a
    x.move()
    x = b
    x.move()
}

完整代码：

package main

import "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 Mover
	var a = dog{name: "旺财"}
	var b = car{brand: "保时捷"}
	x = a
	x.move()
	x = b
	x.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 main

import "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 {
    Sayer
    Mover
}

嵌套得到的接口的使用与普通接口一样，这里我们让 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 main

import "fmt"

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

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

// 接口嵌套
type animal interface {
	Sayer
	Mover
}

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 animal
	x = cat{name: "花花"}
	x.move()
	x.say()
}

输出结果：

猫会动
喵喵喵

8. 空接口

（1）空接口的定义

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

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

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

package main

import "fmt"

func main() {
	// 定义一个空接口x
	var x interface{}
	s := "pprof.cn" //字符串变量
	x = s
	fmt.Printf("type:%T value:%v\n", x, x)
	i := 100        //整型变量
	x = i
	fmt.Printf("type:%T value:%v\n", x, x)
	b := true       //布尔变量
	x = b
	fmt.Printf("type:%T value:%v\n", x, x)
}

输出结果：

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

（2）空接口的应用

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

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

// 空接口作为函数参数
func show(a interface{}) {
    fmt.Printf("type:%T value:%v\n", 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.cn"
    v, ok := x.(string)  //判断 x 是字符串类型
    if ok {   //true 
        fmt.Println(v)
    } else {  //false 
        fmt.Println("类型断言失败")
    }
}

输出结果：

pprof.cn

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

package main

import "fmt"

func justifyType(x interface{}) {
	switch v := x.(type) {
	case string:
		fmt.Printf("x is a string，value is %v\n", v)
	case int:
		fmt.Printf("x is a int is %v\n", v)
	case bool:
		fmt.Printf("x is a bool is %v\n", v)
	default:
		fmt.Println("unsupport type！")
	}
}

func main() {
	var s interface{}
	var a = true
	s = a
	justifyType(s)
}

输出结果：

x is a bool is true

因为空接口可以存储任意类型值的特点，所以空接口在Go语言中的使用十分广泛。

9. 什么时候需要写接口？

关于接口需要注意的是，只有当有 两个或两个以上的具体类型 必须以相同的方式进行处理 时才需要定义接口。比如猫、狗是两个具体类型，它们都会叫，这样的话定义一个 “Sayer” 的接口，就好处理了。

不要为了接口而写接口，那样只会增加不必要的抽象，导致不必要的运行时损耗。

三、参考链接

  1. 面向对象

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。

文章由极客之音整理，本文链接：https://www.bmabk.com/index.php/post/119004.html

赞 (0)
seven_的头像seven_bm
0 0

相关推荐

发表回复

登录后才能评论
极客之音——专业性很强的中文编程技术网站，欢迎收藏到浏览器，订阅我们！