这里的接口，可不是说那种插槽的那种接口，互相怼到一块就完事了。
在各种语言中，提到接口，通常指的之一种规范，然后具体对象来实现这个规范的细节。
本文使用的接口主要是约束接口，还有一种存储接口。
注:
在Go中，接口(interface)是一种类型，一种抽象类型，它只有方法，没有属性。
我们在讲结构体时，Go语言基础之结构体（春日篇）、Go语言基础之结构体（夏日篇）、Go语言基础之结构体（秋日篇），提到过继承这个概念，Go是通过结构体来完成继承的。
//车
type Car struct {
Brand string //车品牌
CarNum string //车牌号
Tyre int //轮胎个数
}
//给车绑定一个方法，说明车的基本信息
func (this *Car) carInfo() {
fmt.Printf("品牌:%s，车牌号:%s，轮胎个数:%d\n"， this.Brand， this.CarNum， this.Tyre)
}车结构体有四个属性，同时还有一个显示车(carInfo)信息的方法。
//宝马车
type BMWCar struct {
//*Car和Car基本没有区别，一个存的是整个结构体，一个存的是结构体地址，用法大同小异
*Car //这就表示继承了Car这个结构体
}//比亚迪车
type BYDCar struct {
*Car
}func main() {
//一个宝马对象
var bmw1 = BMWCar{&Car{
Brand: "宝马x8"，
CarNum: "京666"，
Tyre: 4，
}
}
//一个比亚迪对象
var byd1 = BYDCar{&Car{
Brand: "比亚迪L3"，
CarNum: "京111"，
Tyre: 4，
}
}
//因为 BMWCar 和 BYDCar 都继承了Car，所以都有carInfo这个方法
bmw1.carInfo()
byd1.carInfo()
}
通过回顾，我们可以发现，车，应该作为一个基本的概念。
上述Car结构体似乎显示了车的属性，其实是不太对的。
车就是一个抽象的概念，电瓶车是车，小轿车也是车，大卡车也是车。
这些车至少有一个统一的功能，那就是跑，但是像几个轮胎了，什么品牌了。
应该是属于自己的，不再是属于Car这个抽象的概念中了，所以，这时候用接口会更好。
type Car interface {
//车会跑
Run(speed int)
//车需要加油
Refuel(oil int)
//车需要转弯
Wheel(direction string)
}假设车，至少有这三个动作，不管任何结构体，只要实现了Car里面的所有方法，就代表它一定是一个车。
//宝马车
type BMWCar struct {
Owner string //车主
Brand string //车品牌
CarNum string //车牌号
}
//构造方法
func NewBMWCar(owner string， brand string， carNum string) *BMWCar {
return &BMWCar{Owner: owner， Brand: brand， CarNum: carNum}
}
func (this *BMWCar) Run(speed int) {
fmt.Printf("我是 %s，我的车是 %s，我车牌号为 %s，我正在以 %d 速度行驶\n"， this.Owner， this.Brand， this.CarNum， speed)
}
func (this *BMWCar) Refuel(oil int) {
fmt.Printf("老板，加%d升油\n"， oil)
}
func (this *BMWCar) Wheel(direction string) {
fmt.Printf("我正在%s转弯\n"， direction)
}
//电瓶车
type Electromobile struct {
Owner string //车主
Brand string //车品牌
}
func NewElectromobile(owner string， brand string) *Electromobile {
return &Electromobile{Owner: owner， Brand: brand}
}
func (this *Electromobile) Run(speed int) {
fmt.Printf("我是 %s，我的车是 %s，我正在以 %d 速度行驶\n"， this.Owner， this.Brand，， speed)
}
func (this *Electromobile) Refuel(oil int) {
fmt.Printf("你妹的，你电动车加啥油...\n")
}
func (this *Electromobile) Wheel(direction string) {
fmt.Printf("我正在%s转弯\n"， direction)
}这里是有区别的，电瓶车没有属性CarNum，但是仍然实现了Car接口的所有方法，所以电瓶车在代码上，仍然是车。
func main() {
var 张三的车 Car
张三的车 = NewBMWCar("张三"， "宝马6"， "京666")
张三的车.Run(80)
张三的车.Refuel(20)
张三的车.Wheel("左")
var 李四的车 Car
李四的车 = NewElectromobile("李四"， "小刀电动车")
李四的车.Run(40)
李四的车.Refuel(0)
李四的车.Wheel("左")
}第2行代码和第8行代码，变量类型是Car接口类型，但是在赋值时，确是其他类型。
Go是强类型语言，为什么类型不一致，还可以赋值，那执行结果会出问题吗？？？
执行结果
但是我们发现执行结果是没问题的。
但是为啥变量类型不一致，还是可以进行赋值并且每报错呢？
我们上述代码可以确定宝马车和电瓶车完全实现了Car接口里面所有的方法。
所以可以理解为Car就是他们的爸爸，用他们的爸爸来接收儿子，当然可以咯。
以下代码没有实际意义，完全是为了语法而语法。
接口代码//跑接口
type Runer interface {
Run()
}
// 跳接口
type Jumper interface {
Jump()
}//袋鼠结构体
type Roo struct {
Name string
}
func (this *Roo) Jump() {
fmt.Println("我是袋鼠，我会跳")
}
func (this *Roo) Run() {
fmt.Println("我是袋鼠，我会跑")
}这个结构体同时实现了两个结构，一个是Runer，一个是Jumper。
func main() {
var runner Runer
var jumper Jumper
runner = &Roo{Name: "袋鼠"}
jumper = &Roo{Name: "袋鼠"}
runner.Run()
jumper.Jump()
}Roo既然实现了两个接口，自然两个接口都可以接收Roo这个结构体。
接口嵌套这个有点像组合，比如有跑，跳，吃等这些操作。
例如一个动物，因该是要有这些操作的，那这个动物应该也是一个接口。
并且把这些动作都拿过来才对。
//跑接口
type Runer interface {
Run()
}
// 跳接口
type Jumper interface {
Jump()
}
//动物接口，继承了 跑 和 跳
type Animal interface {
Runer
Jumper
}//袋鼠结构体，实现了跑和跳
type Roo struct {
Name string
}
func (this *Roo) Jump() {
fmt.Println("我是袋鼠，我会跳")
}
func (this *Roo) Run() {
fmt.Println("我是袋鼠，我会跑")
}func main() {
var animal Animal
animal = &Roo{Name: "袋鼠"}
animal = &Roo{Name: "袋鼠"}
animal.Run()
animal.Jump()
}
上述我们学习了Go基础的接口，主要学习了接口和继承的区别，一个结构体实现多个接口，接口嵌套。
可能不太好理解，但是一定要尝试做一下，一定要坚持！