一篇文章带你了解Go语言基础之接口（上篇）

 前言

Hey，篇文大家好呀，章带我是解G接口码农，星期八，语言基之前怎么学到过面向对象的上篇相关知识，但是篇文还差一点，差了个接口。章带

并且接口在代码中用的解G接口还是比较多的，一起来看看吧!

什么是语言基接口(interface)

这里的接口，可不是上篇说那种插槽的那种接口，互相怼到一块就完事了。篇文

在各种语言中，章带提到接口，解G接口通常指的语言基之一种规范，然后具体对象来实现这个规范的上篇细节。

本文使用的接口主要是约束接口，还有一种存储接口。

注:

在Go中，接口(interface)是一种类型，香港云服务器一种抽象类型，它只有方法，没有属性。

为什么需要接口

我们在讲结构体时，Go语言基础之结构体(春日篇)、Go语言基础之结构体(夏日篇)、Go语言基础之结构体(秋日篇)，提到过继承这个概念，Go是通过结构体来完成继承的。

回顾继承

车结构体

//车 type Car struct {     Brand  string //车品牌     CarNum string //车牌号     Tyre   int    //轮胎个数 } //给车绑定一个方法，说明车的基本信息 func (this *Car) carInfo() {     fmt.Printf("品牌:%s，车牌号:%s，轮胎个数:%dn"， this.Brand， this.CarNum， this.Tyre) } 

车结构体有四个属性，同时还有一个显示车(carInfo)信息的方法。

宝马车

//宝马车 type BMWCar struct {     //*Car和Car基本没有区别，一个存的是整个结构体，一个存的是结构体地址，用法大同小异     *Car //这就表示继承了Car这个结构体 } 

比亚迪车

//比亚迪车 type BYDCar struct {     *Car } 

main代码

func main() {     //一个宝马对象     var bmw1 = BMWCar{&Car{         Brand:  "宝马x8"，         CarNum: "京666"，         Tyre:   4，     } }     //一个比亚迪对象     var byd1 = BYDCar{&Car{         Brand:  "比亚迪L3"，         CarNum: "京111"，b2b供应网         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接口的所有方法，所以电瓶车在代码上，仍然是车。

main

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。

main代码

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("我是袋鼠，我会跑") } 

main代码

func main() {   var animal Animal   animal = &Roo{Name: "袋鼠"}   animal = &Roo{Name: "袋鼠"}   animal.Run()   animal.Jump() } 

执行结果

总结

上述我们学习了Go基础的接口，主要学习了接口和继承的区别，一个结构体实现多个接口，接口嵌套。

可能不太好理解，但是一定要尝试做一下，一定要坚持!