• [go学习笔记.第十章.面向对象编程] 10.面向对象的特性-接口

    1.基本介绍

    接口（ interface ) ，在 Golang 中多态特性主要是通过接口来体现的

    2.快速入门

    1. package main
    2.  
    3. import(
    4.     "fmt"
    5. )
    6.  
    7. // 声明一个接口
    8. type Usb interface {
    9.     //声明了两个没有实现的方法
    10.     Start()
    11.     Stop()
    12. }
    13.  
    14. //声明一个结构体,实现Usb方法
    15. type Phone struct{
    16.  
    17. }
    18.  
    19. func (p Phone) Start()  {
    20.     fmt.Println("手机开始工作...")
    21. }
    22. func (p Phone) Stop()  {
    23.     fmt.Println("手机停止工作...")
    24. }
    25.  
    26. //相机实现Usb方法
    27. type Camera struct{
    28.  
    29. }
    30.  
    31. func (c Camera) Start()  {
    32.     fmt.Println("相机开始工作...")
    33. }
    34. func (c Camera) Stop()  {
    35.     fmt.Println("相机停止工作...")
    36. }
    37.  
    38. //计算机
    39. type Computer struct{
    40.  
    41. }
    42. //编写一个方法Working, 接收一个Usb接口类型变量
    43. //实现了Usb接口(就是指实现了Usb接口声明的所有方法)
    44. func (c Computer) Working(usb Usb)  {
    45.     //通过Usb接口变量来调用Start,Stop方法
    46.     usb.Start()
    47.     usb.Stop()
    48. }
    49.  
    50. func main()  {
    51.     //先创建结构体变量
    52.     computer := Computer{}
    53.     phone := Phone{}
    54.     camera := Camera{}
    55.  
    56.     //关键点
    57.     computer.Working(phone)
    58.     computer.Working(camera)
    59. }
    60. 手机开始工作...
    61. 手机停止工作...
    62. 相机开始工作...
    63. 相机停止工作...

    接口概念的再说明

    interface 类型可以定义一组方法，但是这些不需要实现,并且 interfaoe 不能包含任何变量,到某个自定义类型（比如结构体 Phone ）要使用的时候,再根据具体情况把这些方法写出来(实现)

    3.基本语法

    type 接口名 interface {

            method1(参数列表) 返回值列表

            method2(参数列表) 返回值列表

    } 

    实现接口的方法:

    function (t 自定义类型) method1(参数列表) 返回值列表{

            //方法实现

    }

    function (t 自定义类型) method2(参数列表) 返回值列表{

            //方法实现

    }

    小节说明

    (1).接口里的所有方法都没有方法体，即接口的方法都是没有实现的方法。接口体现了程序设计的多态和高内聚低偶合的思想

    (2 ). go中的接口，不需要显式的实现,只要一个变量，含有接口类型中的所有方法，那么这个变量就实现这个接口。因此， Golang 中没有implement 这样的关键字

    应用场景

    4.接口的注意事项和细节

    (1).接口本身不能创建实例，但是可以指向一个实现了该接口的自定义类型的变量(实例)

    1. package main
    2.  
    3. import(
    4.     "fmt"
    5. )
    6.  
    7. type AInterface interface{
    8.     Say()
    9. }
    10.  
    11. type Student struct{
    12.     Name string
    13. }
    14. func (stu Student) Say(){
    15.     fmt.Println("Stu Say()")
    16. }
    17.  
    18. func main()  {
    19.     var stu Student //结构体变量,实现了Say(),也就实现了AInterface接口
    20.     var a AInterface = stu
    21.     a.Say()
    22. }

    (2).接口中的所有的方法都没有方法体,即都没有实现的方法

    (3).在go中,一个自定义类型需要将某个接口的所有方法都实现,才会说这个自定义类型实现了该接口

    (4).一个自定义类型只有实现了某个接口，才能将该自定义类型的实例（变量）赋给接口类型

    (5 ).只要是自定义数据类型，就可以实现接口，不仅仅是结构体类型

    1. package main
    2.  
    3. import(
    4.     "fmt"
    5. )
    6. type integer int
    7. func (i integer) Say()  {
    8.     fmt.Println("i integer, i=", i)
    9. }
    10. func main()  {
    11.     var i integer = 10
    12.     var b AInterface = i
    13.     b.Say()//i integer, i= 10
    14. }

    (6).一个自定义类型可以实现多个接口

    1. package main
    2.  
    3. import(
    4.     "fmt"
    5. )
    6.  
    7. type AInterface interface{
    8.     Say()
    9. }
    10. type BInterface interface{
    11.     Hello()
    12. }
    13.  
    14. type Monster struct{
    15.  
    16. }
    17. func (m Monster) Say() {
    18.     fmt.Println("Monster Say()")
    19. }
    20. func (m Monster) Hello() {
    21.     fmt.Println("Monster Hello()")
    22. }
    23. func main()  {
    24.     //Monster实现了AInterface,BInterface
    25.     var monster Monster
    26.     var a1 AInterface = monster
    27.     var b1 BInterface = monster
    28.     a1.Say()
    29.     b1.Hello()
    30. }

    (7).go接口不能有任何变量

    (8).一个接口（比如A接口 ）可以继承多个别的接口（比如 B , C 接口），这时如果要实现A接口，也必须将 B ,C 接口的方法也全部实现

    1. package main
    2.  
    3. import(
    4.     "fmt"
    5. )
    6.  
    7. type BInterface interface{
    8.     test01()
    9. }
    10. type CInterface interface{
    11.     test02()
    12. }
    13. type AInterface interface{
    14.     BInterface
    15.     CInterface
    16.     test03()
    17. }
    18.  
    19. //如果需要实现AInterface,就需要把BInterface,CInterface额方法都实现
    20. type Stu struct{
    21.  
    22. }
    23. func (stu Stu) test01() {
    24.     
    25. }
    26. func (stu Stu) test02() {
    27.     
    28. }
    29. func (stu Stu) test03() {
    30.     
    31. }
    32.  
    33. func main()  {
    34.     var stu Stu
    35.     var a AInterface = stu
    36.     a.test01()
    37. }

    (9).interface 类型默认是一个指针，如果没有对interface 初始化就使用，那么会输出nil

    (10).空接口interface{}没有任何方法,所有所有类型都实现了空接口

    1. package main
    2.  
    3. import(
    4.     "fmt"
    5. )
    6.  
    7. //空接口
    8. type T interface{
    9.  
    10. }
    11. func main()  {
    12.     var t T = stu //ok
    13.     fmt.Println(t)  //{}
    14.  
    15.     var t2 interface{} = stu
    16.     fmt.Println(t2) //{}
    17.     var num float64 = 2.33
    18.     t2 = num
    19.     fmt.Println(t2)// 2.33
    20. }

    5.接口案例

    实现对Hero结构体切片的排序:sort.Sort(data.Interface) 

    1. package main
    2.  
    3. import (
    4.     "fmt"
    5.     "sort"
    6.     "math/rand"
    7. )
    8.  
    9. //实现对Hero结构体切片的排序:sort.Sort(data interface)
    10. //1.声明一个Here结构体
    11. type Hero struct {
    12.     Name string
    13.     Age int
    14. }
    15.  
    16. //2.声明一个Here结构体切片
    17. type HeroSlice []Hero
    18.  
    19. //3.实现接口Interface接口
    20. // func Sort(data Interface)
    21. /*
    22. type Interface interface {
    23.     // Len方法返回集合中的元素个数
    24.     Len() int
    25.     // Less方法报告索引i的元素是否比索引j的元素小
    26.     Less(i, j int) bool
    27.     // Swap方法交换索引i和j的两个元素
    28.     Swap(i, j int)
    29. }
    30. */
    31. func (hs HeroSlice) Len() int {
    32.     return len(hs)
    33. }
    34. //Less就是决定你使用什么标准进行排序
    35. //1. 按照Here的年龄从小到大排序
    36. //2.修改成对名字进行排序
    37. func (hs HeroSlice)  Less(i, j int) bool {
    38.     // 1. 按照Here的年龄从小到大排序
    39.     // return hs[i].Age < hs[j].Age //升序
    40.     // 2.修改成对名字进行排序
    41.     return hs[i].Name < hs[j].Name  //升序
    42. }
    43. func (hs HeroSlice)  Swap(i, j int) {
    44.     //交换
    45.     // temp := hs[i]
    46.     // hs[i] = hs[j]
    47.     // hs[j] = temp
    48.     // 上面的三句等价于下面的一句
    49.     hs[i], hs[j] = hs[j], hs[i]
    50. }
    51.  
    52. func main()  {
    53.     //先定义一个数组/切片
    54.     var intSlice = []int{12, -1, 4, 2, 15}
    55.     //要求对intSlice切片进行排序
    56.     //1.冒泡排序
    57.     //2.使用系统提供的方法
    58.     sort.Ints(intSlice)
    59.     fmt.Println(intSlice)
    60.  
    61.     //对结构体进行排序
    62.     //1.冒泡排序
    63.     //2.也可以使用系统提供的方法
    64.  
    65.     //对结构体切片进行排序
    66.     var heroes HeroSlice
    67.     for i := 0; i < 10; i++ {
    68.         hero := Hero {
    69.             Name : fmt.Sprintf("英雄%d", rand.Intn(100)),
    70.             Age : rand.Intn(100),
    71.         }
    72.         //将hero append 到heroes切片
    73.         heroes = append(heroes, hero)
    74.     }
    75.  
    76.     //排序前的顺序
    77.     for _, v := range heroes {
    78.         fmt.Println(v)
    79.     }
    80.     //调用sort.Sort
    81.     sort.Sort(heroes)
    82.  
    83.     //排序后的顺序
    84.     fmt.Println("排序后")
    85.     for _, v := range heroes {
    86.         fmt.Println(v)
    87.     }
    88. }

     实现对Student结构体切片按照成绩升序进行排序

    1. package main
    2.  
    3. import (
    4.     "fmt"
    5.     "math/rand"
    6.     "sort"
    7. )
    8.  
    9. //实现对Student结构体切片按照成绩升序进行排序
    10. //1.声明一个Student结构体
    11. type Student struct{
    12.     Name string
    13.     Age int
    14.     Score float64
    15. }
    16.  
    17. //2.声明一个Student切片
    18. type StuSlice []Student
    19.  
    20. //3.实现接口Interface接口
    21. // func Sort(data Interface)
    22. /*
    23. type Interface interface {
    24.     // Len方法返回集合中的元素个数
    25.     Len() int
    26.     // Less方法报告索引i的元素是否比索引j的元素小
    27.     Less(i, j int) bool
    28.     // Swap方法交换索引i和j的两个元素
    29.     Swap(i, j int)
    30. }
    31. */
    32. func (stu StuSlice) Len() int  {
    33.     return len(stu)
    34. }
    35. func (stu StuSlice)Less(i, j int) bool  {
    36.     return stu[i].Score < stu[j].Score
    37. }
    38. func (stu StuSlice) Swap(i, j int)  {
    39.     stu[i], stu[j] = stu[j], stu[i]
    40. }
    41.  
    42. func main()  {
    43.     //创建一个Student切片实例
    44.     var stues StuSlice
    45.     for i := 0; i <=10 ; i++ {
    46.         stu := Student{
    47.             Name : fmt.Sprintf("学生%v", rand.Intn(100)),
    48.             Age : rand.Intn(100),
    49.             Score : float64(rand.Intn(100)),
    50.         }
    51.         //把stu append 到stues结构体实例变量中
    52.         stues = append(stues, stu)
    53.     }
    54.  
    55.     //排序前数据
    56.     for _,v := range stues {
    57.         fmt.Println(v)
    58.     }
    59.     //排序后数据
    60.     fmt.Println("排序后数据")
    61.     sort.Sort(stues)
    62.     for _,v := range stues {
    63.         fmt.Println(v)
    64.     }
    65. }

    6.接口和继承的比较

    1. package main
    2.  
    3. import(
    4.     "fmt"
    5. )
    6.  
    7. //声明一个鸟儿接口
    8. type BridAble interface {
    9.     Flying()    
    10. }
    11. //声明一个鱼儿接口
    12. type FishAble interface {
    13.     Swimming()  
    14. }
    15.  
    16. //Monkey
    17. type Monkey struct{
    18.     Name string
    19. }
    20.  
    21. func (this *Monkey) climbing() {
    22.     fmt.Println(this.Name, "会爬树")
    23. }
    24.  
    25. //LittleMonkey结构体
    26. type LittleMonkey struct{
    27.     Monkey // 继承
    28. }
    29.  
    30. //让LittleMonkey实现BridAble.Flying
    31. func (this *LittleMonkey) Flying() {
    32.     fmt.Println(this.Name, "通过学习,学会了飞翔")
    33. }
    34. //让LittleMonkey实现FishAble.Swimming
    35. func (this *LittleMonkey) Swimming() {
    36.     fmt.Println(this.Name, "通过学习,学会了游泳")
    37. }
    38. func main()  {
    39.     //创建一个LitteMonkey实例
    40.     littleMonkey := LittleMonkey{
    41.         Monkey {
    42.             Name : "猴子1",
    43.         },
    44.     }
    45.     littleMonkey.climbing()
    46.     littleMonkey.Flying()
    47.     littleMonkey.Swimming()
    48. }

    对上面代码的小结 :

    (1).当 A 结构体继承了 B 结构体，那么 A 结构就自动的继承了 B 结构体的字段和方法，并且可以直接使用

    (2 ).当 A 结构体需要扩展功能同时不希望去破坏继承关系，则可以去实现某个接口即可，因此可以认为：实现接口是对继承机制的补充

    图示说明: 

    接口和继承解决的解决的问题不同

            继承的价值主要在于：解决代码的复用性和可维护性

            接口的价值主要在于：设计，设计好各种规范(方法），让其它自定义类型去实现这些方法

    接口比继承更加灵活 Person Student , BirdAble LitdeMonkev

    接口比继承更加灵活，继承是满足is-a的关系，而接口只需满足 like - a的关系

    接口在一定程度上实现代码解藕

    [上一节][go学习笔记.第十章.面向对象编程] 9.面向对象的三大特性-继承 

  • 相关阅读:
    JavaScript逻辑题：输出1000之内的所有完数。所谓完数指的是：如果一个数恰好等于它的所有因子之和，这个数就称为完数。
    微信服务商模式(电商收付通)合单支付APIV3完整Demo,可直接使用,适用于(H5、JSAPI、H5、App、小程序)
    葡萄糖-聚乙二醇-巯基Glucose-PEG-Alkyne|葡萄糖-聚乙二醇-生物素Glucose-PEG-Biotin
    笔试刷题Day—1
    Linux-进程间通信
    P4630 [APIO2018] 铁人两项 (广义圆方树)
    PHP命令行脚本接收传入参数的三种方式
    python表白弹框
    安装TPDSS
    时间轮(Timing Wheel)案例和原理
  • 原文地址：https://blog.csdn.net/zhoupenghui168/article/details/125901643