输出结果：
{{5lmh man 20} 1 bj}
{{5lmh man 20} 0 }
{{5lmh 0} 0 }
同名字段的情况
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}
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}
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)
}
输出结果：
接口
接口定义了一个对象的行为规范，只定义规范不实现，由具体的对象来实现规范的细节。
接口是一种类型
在Go语言中接口是一种类型，一种抽象的类型。
interface是一组method的集合，是duck-typeprogramming的一种体现。接口做的事情就像是定义一个协议，只要一台机器有洗衣服和甩干的功能，我就称它为洗衣机。不关心属性，只关心行为。
为了保护你的Go语言职业生涯，请牢记接口是一种类型。
为什么要使用接口
实例：
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语言中为了解决类似上面的问题，就设计了接口这个概念。接口区别于我们之前所有的具体类型，接口是一种抽象的类型。当你看到一个接口类型的值时，你不知道它是什么，唯一知道的是通过它的方法能做什么。
接口的定义
Go语言提倡面向接口编程。
接口是一个或多个方法的签名的集合。任何类型的方法集中只要拥有该接口对应的全部方法签名，就表示它“实现”了该接口，无须在该类型上显式声明实现了哪个接口。这称为StructuralTyping。所谓对应方法，是指有相同名称、参数列表(不包括参数名)以及返回值。该类型还可以有其他方法。
注意：
接口定义的语法：
每个接口由数个方法组成，接口的定义格式如下：
type 接口类型名 interface{
方法名1( 参数列表1 ) 返回值列表1
方法名2( 参数列表2 ) 返回值列表2
…
}
其中：
接口名：使用type将接口定义为自定义的类型名。Go语言的接口在命名时，一般会在单词后面添加er，如有写操作的接口叫Writer，有字符串功能的接口叫Stringer等。接口名最好要能突出该接口的类型含义。方法名：当方法名首字母是大写且这个接口类型名首字母也是大写时，这个方法可以被接口所在的包之外的代码访问。参数列表、返回值列表：参数列表和返回值列表中的参数变量名可以省略。
举个例子：
当你看到这个接口类型的值时，你不知道它是什么，唯一知道的就是可以通过它的Write方法来做一些事情。
实现接口的条件
一个对象只要实现了接口中的全部方法，那么就实现了这个接口。换句话说，接口就是一个需要实现的方法列表。
我们来定义一个Sayer接口：
定义dog和cat两个结构体：
因为Sayer接口里只有一个say方法，所以我们只需要给dog和cat分别实现say方法就可以实现Sayer接口了。
// cat实现了Sayer接口
func (c Cat) Say() {
fmt.Println('喵喵喵')
}
// dog实现了Sayer接口
func (d Dog) Say() {
fmt.Println('汪汪汪')
}
接口的实现就是这么简单，只要实现了接口中的所有方法，就实现了这个接口。
接口类型变量
那实现了接口有什么用呢？
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()
}
输出结果：
喵喵喵
汪汪汪
值接收者和指针接收者实现接口的区别
使用值接收者实现接口和使用指针接收者实现接口有什么区别呢？接下来我们通过一个例子看一下其中的区别。
我们有一个Mover接口和一个dog结构体。
值接收者实现接口
值接收者是：在结构体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。
指针接收者实现接口
同样的代码我们再来测试一下使用指针接收者有什么区别：
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))
}
输出结果：
您好
类型与接口的关系
一个类型实现多个接口
一个类型可以同时实现多个接口，而接口间彼此独立，不知道对方的实现。例如，狗可以叫，也可以动。我们就分别定义Sayer接口和Mover接口，如下：
类型dog既可以实现Sayer接口，也可以实现Mover接口：
type dog struct {
name string
}
// 实现Sayer接口
func (d dog) say() {
fmt.Printf('%s会叫汪汪汪
', d.name)
}
// 实现Mover接口
func (d dog) move() {
fmt.Printf('%s会动
', 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会叫汪汪汪
', d.name)
}
// 实现Mover接口
func (d dog) move() {
fmt.Printf('%s会动
', d.name)
}
func main() {
var x Sayer
var y Mover
var a = dog{name: '旺财'}
x = a
y = a
x.say()
y.move()
}
输出结果：
旺财会叫汪汪汪
旺财会动
多个类型实现同一接口
Go语言中不同的类型还可以实现同一接口。
首先我们定义一个Mover接口，它要求必须有一个move方法。
例如狗可以动，汽车也可以动，可以使用如下代码实现这个关系：
type dog struct {
name string
}
type car struct {
brand string
}
// dog类型实现Mover接口
func (d dog) move() {
fmt.Printf('%s会跑
', d.name)
}
// car类型实现Mover接口
func (c car) move() {
fmt.Printf('%s速度70迈
', 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会跑
', d.name)
}
// car类型实现Mover接口
func (c car) move() {
fmt.Printf('%s速度70迈
', 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()方法，所以没能实现接口。所以如果你把varxWashingMachine=haier{}改成varxWashingMachine=dryer{}就会报错：cannotusedryer{}(typedryer)astypeWashingMachineinassignment:dryerdoesnotimplementWashingMachine(missingwashmetho
输出结果：
洗刷刷
甩一甩
接口嵌套
接口与接口间可以通过嵌套创造出新的接口。
// 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()
}
输出结果：
猫会动
喵喵喵
空接口
空接口的定义
空接口是指没有定义任何方法的接口。因此任何类型都实现了空接口。
Important：空接口类型的变量可以存储任意类型的变量。
也就是说，我们创建一个空接口变量，它可以被赋予任何值。
package main
import 'fmt'
func main() {
// 定义一个空接口x
var x interface{}
s := 'pprof.cn' //字符串变量
x = s
fmt.Printf('type:%T value:%v
', x, x)
i := 100 //整型变量
x = i
fmt.Printf('type:%T value:%v
', x, x)
b := true //布尔变量
x = b
fmt.Printf('type:%T value:%v
', x, x)
}
输出结果：
空接口的应用
>空接口作为函数的参数。使用空接口实现可以接收任意类型的函数参数。
// 空接口作为函数参数
func show(a interface{}) {
fmt.Printf('type:%T value:%v
', a, a)
}
>空接口作为map的值。
使用空接口实现可以保存任意值的字典。
// 空接口作为map值
var studentInfo = make(map[string]interface{})
studentInfo['name'] = '李白'
studentInfo['age'] = 18
studentInfo['married'] = false
fmt.Println(studentInfo)
>类型断言。
空接口可以存储任意类型的值，那我们如何获取其存储的具体数据呢？
接口值：一个接口的值是由一个具体类型和具体类型的值两部分组成的。这两部分分别称为接口的动态类型和动态值。
我们来看一个具体的例子：
请看下分解：想要判断空接口中的值，这个时候就可以使用类型断言，其语法格式：
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('类型断言失败')
}
}
输出结果：
上面的示例中如果要断言多次就需要写多个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
', v)
case int:
fmt.Printf('x is a int is %v
', v)
case bool:
fmt.Printf('x is a bool is %v
', v)
default:
fmt.Println('unsupport type！')
}
}
func main() {
var s interface{}
var a = true
s = a
justifyType(s)
}
输出结果：
因为空接口可以存储任意类型值的特点，所以空接口在Go语言中的使用十分广泛。
什么时候需要写接口？
关于接口需要注意的是，只有当有两个或两个以上的具体类型必须以相同的方式进行处理时才需要定义接口。比如猫、狗是两个具体类型，它们都会叫，这样的话定义一个“Sayer”的接口，就好处理了。
不要为了接口而写接口，那样只会增加不必要的抽象，导致不必要的运行时损耗。
参考链接
面向对象
文章为作者独立观点，不代表股票交易接口观点
股民评论