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

    1.看一个问题,引出继承的必要性

    1. package main
    2.  
    3. import (
    4.     "fmt"
    5. )
    6.  
    7. //编写一个学生考试系统
    8. type Pupil struct {
    9.     Name string
    10.     Age int
    11.     Score float64
    12. }
    13. //显示信息
    14. func (p *Pupil) showInfo() {
    15.     fmt.Printf("学生姓名:%v,年龄:%v,成绩:%v\n", p.Name, p.Age, p.Score)
    16. }
    17. //设置成绩
    18. func (p *Pupil) SetScore(s float64) {
    19.     //逻辑判断
    20.     p.Score = s 
    21. }
    22. //考试状态
    23. func (p *Pupil) status() {
    24.     fmt.Println("正在考试")
    25. }
    26.  
    27. // 大学生,高中生,...
    28. func main() {
    29.     p := &Pupil{
    30.         Name: "Jack",
    31.         Age: 11,
    32.         Score: 110.22,
    33.     }
    34.  
    35.     p.status()//正在考试
    36.     p.SetScore(22)
    37.     p.showInfo()//学生姓名:Jack,年龄:11,成绩:22
    38. }

    对上面代码总结:

    1.Pupil和Graduate两个结构体字段和方法几乎一样,有很多相同的代码

    2.出现代码的冗余,而且代码不利于维护,同时也不利于功能的扩展

    3.解决方法:通过继承方式来解决

    2.继承的基本介绍和图示

    继承可以解决代码的复用,让编程更加靠近人类思维.

            当多个结构体存在相同的属性(字段)和方法时,可以从这些结构体中抽象出结构体,在该结构体中定义这些相同的属性和方法.

            其他结构体不需要重新定义这些属性(字段)和方法,只需要嵌套一个匿名结构体即可

    也就是说:

            在go语言中,如果一个struct嵌套了另一个匿名结构体,那么这个结构体可以直接访问匿名结构体中的字段和方法,从而实现继承特性

     3.嵌套匿名结构体的基本语法

    type Goods struct {

            Name string

            Proce int

    }

    type Book struct {

            Goods         // 这里就是嵌套匿名结构体Goods

            Writer string

    }

     4.案例

    1. package main
    2.  
    3. import (
    4.     "fmt"
    5. )
    6.  
    7. //因为小学生,大学生,高中生都有共有的属性和方法,故抽出来放到Student结构体中
    8. type Student struct {
    9.     Name string
    10.     Age int
    11.     Score float64
    12. }
    13. func (stu *Student) showInfo() {
    14.     fmt.Printf("学生姓名:%v,年龄:%v,成绩:%v\n", stu.Name, stu.Age, stu.Score)
    15. }
    16. //设置成绩
    17. func (stu *Student) SetScore(s float64) {
    18.     //逻辑判断
    19.     stu.Score = s 
    20. }
    21.  
    22. //编写一个学生考试系统
    23.  
    24. // 小学生,大学生,高中生,...
    25. //小学生:
    26. type Pupil struct {
    27.     Student //嵌入了Student匿名的结构体
    28. }
    29. //考试状态:小学生结构体特有的方法,保留
    30. func (p *Pupil) status() {
    31.     fmt.Println("小学生正在考试")
    32. }
    33.  
    34. //大学生:
    35. type Graduate struct {
    36.     Student //嵌入了Student匿名的结构体
    37. }
    38. //考试状态:大学生结构体特有的方法,保留
    39. func (g *Graduate) status() {
    40.     fmt.Println("大学生正在考试")
    41. }
    42.  
    43. func main() {
    44.     //当对结构体嵌入了匿名的结构体时,使用的方法会发生变化
    45.     p := &Pupil{}
    46.     p.Student.Name = "jack"
    47.     p.Student.Age = 1
    48.     p.status()//小学生正在考试
    49.     p.Student.SetScore(90.01)
    50.     p.Student.showInfo()//学生姓名:jack,年龄:1,成绩:90.01 
    51.  
    52.     g := &Graduate{}
    53.     g.Student.Name = "Mary"
    54.     g.Student.Age = 23
    55.     g.status()//大学生正在考试
    56.     g.Student.SetScore(190.01)
    57.     g.Student.showInfo()//学生姓名:Mary,年龄:23,成绩:190.01
    58. }

    1. package main
    2.  
    3. import (
    4.     "fmt"
    5. )
    6.  
    7. //因为小学生,大学生,高中生都有共有的属性和方法,故抽出来放到Student结构体中
    8. type Student struct {
    9.     Name string
    10.     Age int
    11.     Score float64
    12. }
    13. func (stu *Student) showInfo() {
    14.     fmt.Printf("学生姓名:%v,年龄:%v,成绩:%v\n", stu.Name, stu.Age, stu.Score)
    15. }
    16. //设置成绩
    17. func (stu *Student) SetScore(s float64) {
    18.     //逻辑判断
    19.     stu.Score = s 
    20. }
    21.  
    22. //给Student增加一个方法,那么Pupil,Graduate都可以使用这个方法
    23. func (stu *Student) GetSum(n1 int, n2 int) int {
    24.     return n1 + n2
    25. }
    26.  
    27.  
    28. //编写一个学生考试系统
    29.  
    30. // 小学生,大学生,高中生,...
    31. //小学生:
    32. type Pupil struct {
    33.     Student //嵌入了Student匿名的结构体
    34. }
    35. //考试状态:小学生结构体特有的方法,保留
    36. func (p *Pupil) status() {
    37.     fmt.Println("小学生正在考试")
    38. }
    39.  
    40. //大学生:
    41. type Graduate struct {
    42.     Student //嵌入了Student匿名的结构体
    43. }
    44. //考试状态:大学生结构体特有的方法,保留
    45. func (g *Graduate) status() {
    46.     fmt.Println("大学生正在考试")
    47. }
    48.  
    49. func main() {
    50.     //当对结构体嵌入了匿名的结构体时,使用的方法会发生变化
    51.     p := &Pupil{}
    52.     p.Student.Name = "jack"
    53.     p.Student.Age = 1
    54.     p.status()//小学生正在考试
    55.     p.Student.SetScore(90.01)
    56.     p.Student.showInfo()//学生姓名:jack,年龄:1,成绩:90.01 
    57.     result := p.Student.GetSum(10, 20)
    58.  
    59.     fmt.Println(result)
    60.     g := &Graduate{}
    61.     g.Student.Name = "Mary"
    62.     g.Student.Age = 23
    63.     g.status()//大学生正在考试
    64.     g.Student.SetScore(190.01)
    65.     g.Student.showInfo()//学生姓名:Mary,年龄:23,成绩:190.01
    66.     result2 := g.Student.GetSum(110, 20)
    67.     fmt.Println(result2)
    68. }

    5.继承给程序带来了便利

    (1).代码的复用性提高了

    (2).代码的扩展性和维护性提高了

    6.继承的深入讨论

    (1). 结构体可以使用嵌套匿名结构体所有的字段和方法,即:首字母大写或者小写的字段,方法都可以使用

    1. package main
    2.  
    3. import(
    4.     "fmt"
    5. )
    6.  
    7. type A struct {
    8.     Name string
    9.     age int
    10. }
    11. func (a *A) SayOk() {
    12.     fmt.Println("A SayOk", a.Name)
    13. }
    14. func (a *A) hello() {
    15.     fmt.Println("A hello", a.Name)
    16. }
    17.  
    18. type B struct {
    19.     A
    20. }
    21. func main() {
    22.     var b B
    23.     b.A.Name = "Mary"
    24.     b.A.age = 10
    25.     b.A.SayOk()//A SayOk Mary
    26.     b.A.hello()//A hello Mary
    27. }

    (2).匿名结构体字段访问可以简化

    1. package main
    2.  
    3. import(
    4.     "fmt"
    5. )
    6.  
    7. type A struct {
    8.     Name string
    9.     age int
    10. }
    11. func (a *A) SayOk() {
    12.     fmt.Println("A SayOk", a.Name)
    13. }
    14. func (a *A) hello() {
    15.     fmt.Println("A hello", a.Name)
    16. }
    17.  
    18. type B struct {
    19.     A
    20. }
    21. func main() {
    22.     var b B
    23.     b.A.Name = "Mary"
    24.     b.A.age = 10
    25.     b.A.SayOk()//A SayOk Mary
    26.     b.A.hello()//A hello Mary
    27.  
    28.     //上面的写法可以简化
    29.     b.Name = "Jack"
    30.     b.age = 20
    31.     b.SayOk()//A SayOk Jack
    32.     b.hello()//A hello Jack
    33. }

    对上面代码的说明:

    1).当我们直接通过 b 访问字段或方法时，其执行流程如下比如 b.Name 
2).编译器会先看 b 对应的类型有没有 Name ，如果有，则直接调用 B 类型的 Name 字段 
3).如果没有就去看 B 中嵌入的匿名结构体 A 有没有声明 Name 字段，如果有就调用,如果役有继续查找,如果都找不到就报错

     (3).当结构体和匿名结构体有相同的字段或者方法时，编译器采用就近访问原则访问，如希望访问匿名结构体的字段和方法，可以通过匿名结构体名来区分

    1. package main
    2.  
    3. import(
    4.     "fmt"
    5. )
    6.  
    7. type A struct {
    8.     Name string
    9.     age int
    10. }
    11. func (a *A) SayOk() {
    12.     fmt.Println("A SayOk", a.Name)
    13. }
    14. func (a *A) hello() {
    15.     fmt.Println("A hello", a.Name)
    16. }
    17.  
    18. type B struct {
    19.     A
    20.     Name string
    21. }
    22.  
    23. func (b *B) SayOk() {
    24.     fmt.Println("B SayOk", b.Name)
    25. }
    26. func main() {
    27.     var b B
    28.     b.Name = "Linda"    //ok 
    29.     
    30.     b.age = 30  //ok
    31.     b.SayOk()//b SayOk Linda
    32.  
    33.     b.hello()//A hello
    34.     b.A.Name = "Tom"
    35.     b.hello()//A hello Tom
    36.     b.A.SayOk()//A SayOk Tom
    37. }

    (4).结构体嵌入两个（或多个）匿名结构体，如两个匿名结构体有相同的字段和方法（同时结构体本身没有同名的字段和方法），在访问时，就必须明确指定匿名结构体名字，否则编译报错

    1. package main
    2.  
    3. import(
    4.     "fmt"
    5. )
    6. type A struct{
    7.     Name string
    8.     age int
    9. }
    10. type B struct{
    11.     Name string
    12.     score float64
    13. }
    14. type C struct{
    15.     A 
    16.     B 
    17.     //Name string
    18. }
    19.  
    20. func main()  {
    21.     var c C 
    22.     //如果C没有Name字段,而A,B有Name,这时就必须通过指定匿名结构体名字区分
    23.     //c.Name报错,编译错误,这个规则对方法同样适用
    24.     // c.Name = "tom"   //error
    25.     // c.A.Name = "tom" //ok
    26.     
    27. }

    (5).如果一个 struct 嵌套了一个有名结构体，这种模式就是组合，如果是组合关系，那么在访问组合的结构体的字段或方法时，必须带上结构体的名字

    1. package main
    2.  
    3. import(
    4.     "fmt"
    5. )
    6. type A struct{
    7.     Name string
    8.     age int
    9. }
    10. //组合结构体
    11. type D struct{
    12.     a A//有名结构体
    13. }
    14. func main()  {
    15.     //如果D中是一个有名结构体,则访问有名结构体的字段时,必须带上有名结构体的名字,如:d.a.Name = "tom"
    16.     var d D 
    17.     // d.Name = "Mary"//error: 结构体D中没有Name,里面有一个有名的结构体A
    18.     d.a.Name = "tom"    //ok
    19.     
    20. }

    (6).嵌套匿名结构体后，也可以在创建结构体变量（实例）时，直接指定各个匿名结构体字段的值

    1. package main
    2.  
    3. import(
    4.     "fmt"
    5. )
    6. type A struct{
    7.     Name string
    8.     age int
    9. }
    10. type B struct{
    11.     Name string
    12.     score float64
    13. }
    14. type C struct{
    15.     A 
    16.     B 
    17.     //Name string
    18. }
    19.  
    20. //组合结构体
    21. type D struct{
    22.     a A//有名结构体
    23. }
    24.  
    25.  
    26. type Goods struct{
    27.     Name string
    28.     Price float64
    29. }
    30.  
    31. type Brand struct{
    32.     Name string
    33.     Address string
    34. }
    35.  
    36. type TV struct {
    37.     Goods
    38.     Brand
    39. }
    40.  
    41. type TV2 struct {
    42.     *Goods
    43.     *Brand
    44. }
    45.  
    46. func main()  {
    47.     // var c C 
    48.     //如果C没有Name字段,而A,B有Name,这时就必须通过指定匿名结构体名字区分
    49.     //c.Name报错,编译错误,这个规则对方法同样适用
    50.     // c.Name = "tom"   //error
    51.     // c.A.Name = "tom" //ok
    52.     
    53.     //如果D中是一个有名结构体,则访问有名结构体的字段时,必须带上有名结构体的名字,如:d.a.Name = "tom"
    54.     var d D 
    55.     // d.Name = "Mary"//error: 结构体D中没有Name,里面有一个有名的结构体A
    56.     d.a.Name = "tom"    //ok
    57.  
    58.     //嵌套匿名结构体后,也可在创建结构体变量(实例)时,直接指定各个匿名结构体字段的值
    59.     tv := TV{Goods{"电视剧机", 110.22}, Brand{"华硕","四川"},}
    60.     fmt.Println("tv:", tv)
    61.     tv2 := TV{
    62.         Goods{
    63.             Name : "电视剧机",
    64.             Price : 110.22,
    65.             },
    66.          Brand{
    67.              Name : "华硕",
    68.              Address : "四川",
    69.             },
    70.         }
    71.     fmt.Println("tv2:", tv2)
    72.     tv3 := TV2{&Goods{"电视剧机", 110.22}, &Brand{"华硕","四川"},}
    73.     fmt.Println("tv3:", *tv3.Goods, *tv3.Brand)
    74.  
    75.     tv4 := TV2{
    76.         &Goods{
    77.             Name : "电视剧机",
    78.             Price : 110.22,
    79.             },
    80.          &Brand{
    81.              Name : "华硕",
    82.              Address : "四川",
    83.             },
    84.         }
    85.     fmt.Println("tv4:" , *tv4.Goods, *tv4.Brand)
    86. }

    说明:

    1).如果一个结构体有int类型的匿名字段,就不能有第二个

    2).如果需要有多个int的字段,则必须给int字段指定名字

    1. package main
    2.  
    3. import(
    4.     "fmt"
    5. )
    6. type Monster struct{
    7.     Name string
    8.     Age int 
    9. }
    10. type E struct{
    11.     Monster
    12.     int
    13.     n int
    14. }
    15.  
    16. func main()  {
    17.     //演示匿名字段是基本数据类型
    18.     var e E 
    19.     e.Name = "猪八戒"
    20.     e.Age = 12
    21.     e.int = 20
    22.     e. = 30
    23.     fmt.Println("e:",e)
    24. }

     7.多重继承

    如一个struct嵌套了多个匿名结构体，那么该结构体可以直接访问嵌套的匿名结构体的字段和方法，从而实现了多重继承
    1. package main
    2.  
    3. import(
    4.     "fmt"
    5. )
    6. type Goods struct{
    7.     Name string
    8.     Price float64
    9. }
    10. type Brand struct{
    11.     Name string
    12.     Address string
    13. }
    14.  
    15. type TV struct {
    16.     Goods
    17.     Brand
    18. }
    19.  
    20. func main()  {
    21.     //嵌套匿名结构体后,也可在创建结构体变量(实例)时,直接指定各个匿名结构体字段的值
    22.     tv := TV{Goods{"电视剧机", 110.22}, Brand{"华硕","四川"},}
    23.     fmt.Println("tv:", tv)
    24.     tv2 := TV{
    25.         Goods{
    26.             Name : "电视剧机",
    27.             Price : 110.22,
    28.             },
    29.          Brand{
    30.              Name : "华硕",
    31.              Address : "四川",
    32.             },
    33.         }
    34.     fmt.Println("tv2:", tv2)

     多重继承细节说明:

            1).如嵌入的匿名结构体有相同的字段名或者方法名，则在访问时，需要通过匿名结构体类型名来区分

             2).为了保证代码的简洁性，建议大家尽量不使用多重继承

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

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

  • 相关阅读:
    Java项目：ssm赛事打分系统
    前端知识学习案例9-开发企业网站9-实现关于我们的部分2
    深度学习实战51-基于Stable Diffusion模型的图像生成原理详解与项目实战
    不要再抱怨项目资源不足了，这么办都能解决
    创新领航 | 竹云参编《基于区块链的数据资产评估实施指南》正式发布！
    如何设置CUDA Kernel中的grid_size和block_size？
    基于小波分析与深度学习的脑电信号分类（matlab）
    linux- socket编程-直接获取网卡-packet- sokcket
    OpenHarmony网络协议通信c-ares [交叉编译]异步解析器库
    ArcGIS Pro地图可视化—双变量关系映射
  • 原文地址：https://blog.csdn.net/zhoupenghui168/article/details/125881381