文章详情

短信预约-IT技能 免费直播动态提醒

请输入下面的图形验证码

提交验证

短信预约提醒成功

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

2024-12-03 15:48

关注

 前言

Hey,大家好呀,我是码农,星期八,之前怎么学到过面向对象的相关知识,但是还差一点,差了个接口。

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

什么是接口(interface)

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

在各种语言中,提到接口,通常指的之一种规范,然后具体对象来实现这个规范的细节。

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

注:

在Go中,接口(interface)是一种类型,一种抽象类型,它只有方法,没有属性。

为什么需要接口

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

回顾继承

车结构体

  1. //车 
  2. type Car struct { 
  3.     Brand  string //车品牌 
  4.     CarNum string //车牌号 
  5.     Tyre   int    //轮胎个数 
  6.  
  7. //给车绑定一个方法,说明车的基本信息 
  8. func (this *Car) carInfo() { 
  9.     fmt.Printf("品牌:%s,车牌号:%s,轮胎个数:%d\n", this.Brand, this.CarNum, this.Tyre) 

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

宝马车

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

比亚迪车

  1. //比亚迪车 
  2. type BYDCar struct { 
  3.     *Car 

main代码

  1. func main() { 
  2.     //一个宝马对象 
  3.     var bmw1 = BMWCar{&Car{ 
  4.         Brand:  "宝马x8", 
  5.         CarNum: "京666", 
  6.         Tyre:   4, 
  7.     } 
  8.     //一个比亚迪对象 
  9.     var byd1 = BYDCar{&Car{ 
  10.         Brand:  "比亚迪L3", 
  11.         CarNum: "京111", 
  12.         Tyre:   4, 
  13.     } 
  14.     //因为 BMWCar 和 BYDCar 都继承了Car,所以都有carInfo这个方法 
  15.     bmw1.carInfo() 
  16.     byd1.carInfo() 

执行结果

 

通过回顾,我们可以发现,车,应该作为一个基本的概念。

上述Car结构体似乎显示了车的属性,其实是不太对的。

车就是一个抽象的概念,电瓶车是车,小轿车也是车,大卡车也是车。

这些车至少有一个统一的功能,那就是跑,但是像几个轮胎了,什么品牌了。

应该是属于自己的,不再是属于Car这个抽象的概念中了,所以,这时候用接口会更好。

定义接口

车接口

  1. type Car interface { 
  2.     //车会跑 
  3.     Run(speed int
  4.     //车需要加油 
  5.     Refuel(oil int
  6.     //车需要转弯 
  7.     Wheel(direction string) 

假设车,至少有这三个动作,不管任何结构体,只要实现了Car里面的所有方法,就代表它一定是一个车。

宝马车

  1. //宝马车 
  2. type BMWCar struct { 
  3.     Owner  string //车主 
  4.     Brand  string //车品牌 
  5.     CarNum string //车牌号 
  6. //构造方法 
  7. func NewBMWCar(owner string, brand string, carNum string) *BMWCar { 
  8.     return &BMWCar{Owner: owner, Brand: brand, CarNum: carNum} 
  9.  
  10. func (this *BMWCar) Run(speed int) { 
  11.     fmt.Printf("我是 %s,我的车是 %s,我车牌号为 %s,我正在以 %d 速度行驶\n", this.Owner, this.Brand, this.CarNum, speed) 
  12.  
  13. func (this *BMWCar) Refuel(oil int) { 
  14.     fmt.Printf("老板,加%d升油\n", oil) 
  15.  
  16. func (this *BMWCar) Wheel(direction string) { 
  17.     fmt.Printf("我正在%s转弯\n", direction) 

电瓶车

  1. //电瓶车 
  2. type Electromobile struct { 
  3.     Owner string //车主 
  4.     Brand string //车品牌 
  5.  
  6. func NewElectromobile(owner string, brand string) *Electromobile { 
  7.     return &Electromobile{Owner: owner, Brand: brand} 
  8. func (this *Electromobile) Run(speed int) { 
  9.     fmt.Printf("我是 %s,我的车是 %s,我正在以 %d 速度行驶\n", this.Owner, this.Brand,, speed) 
  10.  
  11. func (this *Electromobile) Refuel(oil int) { 
  12.     fmt.Printf("你妹的,你电动车加啥油...\n"
  13.  
  14. func (this *Electromobile) Wheel(direction string) { 
  15.     fmt.Printf("我正在%s转弯\n", direction) 

这里是有区别的,电瓶车没有属性CarNum,但是仍然实现了Car接口的所有方法,所以电瓶车在代码上,仍然是车。

main

  1. func main() { 
  2.     var 张三的车 Car 
  3.     张三的车 = NewBMWCar("张三", "宝马6", "京666"
  4.     张三的车.Run(80) 
  5.     张三的车.Refuel(20) 
  6.     张三的车.Wheel("左"
  7.  
  8.     var 李四的车 Car 
  9.     李四的车 = NewElectromobile("李四", "小刀电动车"
  10.     李四的车.Run(40) 
  11.     李四的车.Refuel(0) 
  12.     李四的车.Wheel("左"

第2行代码和第8行代码,变量类型是Car接口类型,但是在赋值时,确是其他类型。

Go是强类型语言,为什么类型不一致,还可以赋值,那执行结果会出问题吗???

执行结果

但是我们发现执行结果是没问题的。

但是为啥变量类型不一致,还是可以进行赋值并且每报错呢?

我们上述代码可以确定宝马车和电瓶车完全实现了Car接口里面所有的方法。

所以可以理解为Car就是他们的爸爸,用他们的爸爸来接收儿子,当然可以咯。

一个结构体实现多个接口

以下代码没有实际意义,完全是为了语法而语法。

接口代码

  1. //跑接口 
  2. type Runer interface { 
  3.   Run() 
  4.  
  5. // 跳接口 
  6. type Jumper interface { 
  7.   Jump() 

结构体代码

  1. //袋鼠结构体 
  2. type Roo struct { 
  3.   Name string 
  4.  
  5. func (this *Roo) Jump() { 
  6.   fmt.Println("我是袋鼠,我会跳"
  7.  
  8. func (this *Roo) Run() { 
  9.   fmt.Println("我是袋鼠,我会跑"

这个结构体同时实现了两个结构,一个是Runer,一个是Jumper。

main代码

  1. func main() { 
  2.   var runner Runer 
  3.   var jumper Jumper 
  4.  
  5.   runner = &Roo{Name"袋鼠"
  6.   jumper = &Roo{Name"袋鼠"
  7.  
  8.   runner.Run() 
  9.   jumper.Jump() 

Roo既然实现了两个接口,自然两个接口都可以接收Roo这个结构体。

执行结果


接口嵌套

接口嵌套这个有点像组合,比如有跑,跳,吃等这些操作。

例如一个动物,因该是要有这些操作的,那这个动物应该也是一个接口。

并且把这些动作都拿过来才对。

接口示例代码

  1. //跑接口 
  2. type Runer interface { 
  3.   Run() 
  4.  
  5. // 跳接口 
  6. type Jumper interface { 
  7.   Jump() 
  8.  
  9. //动物接口,继承了 跑 和 跳  
  10. type Animal interface { 
  11.   Runer 
  12.   Jumper 

结构体代码

  1. //袋鼠结构体,实现了跑和跳 
  2. type Roo struct { 
  3.   Name string 
  4.  
  5. func (this *Roo) Jump() { 
  6.   fmt.Println("我是袋鼠,我会跳"
  7.  
  8. func (this *Roo) Run() { 
  9.   fmt.Println("我是袋鼠,我会跑"

main代码

  1. func main() { 
  2.   var animal Animal 
  3.  
  4.   animal = &Roo{Name"袋鼠"
  5.   animal = &Roo{Name"袋鼠"
  6.  
  7.   animal.Run() 
  8.   animal.Jump() 

执行结果


总结

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

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

 

来源:Go语言进阶学习内容投诉

免责声明:

① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的,并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据,供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。

② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

软考中级精品资料免费领

  • 历年真题答案解析
  • 备考技巧名师总结
  • 高频考点精准押题
  • 2024年上半年信息系统项目管理师第二批次真题及答案解析(完整版)

    难度     813人已做
    查看
  • 【考后总结】2024年5月26日信息系统项目管理师第2批次考情分析

    难度     354人已做
    查看
  • 【考后总结】2024年5月25日信息系统项目管理师第1批次考情分析

    难度     318人已做
    查看
  • 2024年上半年软考高项第一、二批次真题考点汇总(完整版)

    难度     435人已做
    查看
  • 2024年上半年系统架构设计师考试综合知识真题

    难度     224人已做
    查看

相关文章

发现更多好内容

猜你喜欢

AI推送时光机
位置:首页-资讯-后端开发
咦!没有更多了?去看看其它编程学习网 内容吧
首页课程
资料下载
问答资讯