先看不采用继承的情况

小学生考试，大学生考试

代码

  1. package main
  3. import (
  4.     "fmt"
  5. )
  7. type Student struct {
  8. }
  10. // 小学生考试
  11. type Pupil struct {
  12.     Name  string
  13.     Age   int
  14.     Score float64
  15. }
  17. func (p *Pupil) ShowInfo() {
  18.     fmt.Printf("名字：%v, 年龄： %v, 分数：%v \n", p.Name, p.Age, p.Score)
  19. }
  21. func (p *Pupil) SetScore(score float64) {
  22.     p.Score = score
  23. }
  25. func (p *Pupil) testing() {
  26.     fmt.Println("小学生正在考试")
  27. }
  29. // 大学生考试
  30. type Graduate struct {
  31.     Name  string
  32.     Age   int
  33.     Score float64
  34. }
  36. func (p *Graduate) ShowInfo() {
  37.     fmt.Printf("名字：%v, 年龄： %v, 分数：%v \n", p.Name, p.Age, p.Score)
  38. }
  40. func (p *Graduate) SetScore(score float64) {
  41.     p.Score = score
  42. }
  44. func (p *Graduate) testing() {
  45.     fmt.Println("大学生正在考试")
  46. }
  48. func main() {
  49.     // 小学生
  50.     var pupil = &Pupil{
  51.         Name: "tom",
  52.         Age:  6,
  53.     }
  54.     pupil.testing()
  55.     pupil.SetScore(99.89)
  56.     pupil.ShowInfo()
  58.     // 大学生
  60.     var graduate = &Graduate{
  61.         Name: "bill",
  62.         Age:  19,
  63.     }
  64.     graduate.testing()
  65.     graduate.SetScore(99.89)
  66.     graduate.ShowInfo()
  67. }
  70. 小学生正在考试
  71. 名字：tom, 年龄： 6, 分数：99.89 
  72. 大学生正在考试
  73. 名字：bill, 年龄： 19, 分数：99.89

问题引出

  1. 上面 Pupil 和 Graduate 结构体的字段和方法一样，但是却写了相同的代码
  2. 代码冗余，不利于维护，不利于扩展

    解决办法——继承

    继承——解决代码复用
    抽象出一个新的共性的结构体 Student（共同的属性和方法），在这个结构体中定义相同的属性和方法
    其它结构体不需要重复定义这些属性和方法，只需要嵌套一个 Student 匿名结构体即可。

在Golang中，如果一个 struct 嵌套了另一个匿名结构体，那么这个结构体可以直接访问匿名结构体的属性和方法，从而实现了继承。

用继承（嵌套匿名结构体）实现

高复用，可扩展

代码

  1. package main
  3. import (
  4.     "fmt"
  5. )
  7. type Student struct {
  8.     Name  string
  9.     Age   int
  10.     Score float64
  11. }
  13. func (stu *Student) ShowInfo() {
  14.     fmt.Printf("名字：%v, 年龄： %v, 分数：%v \n", stu.Name, stu.Age, stu.Score)
  15. }
  17. func (stu *Student) SetScore(score float64) {
  18.     stu.Score = score
  19. }
  21. // 新增方法
  22. func (stu *Student) DoHomework() {
  23.     fmt.Println("学生在做作业")
  24. }
  26. // 小学生考试
  27. type Pupil struct {
  28.     Student
  29. }
  31. // 保留 Pupil 特有方法
  32. func (p *Pupil) testing() {
  33.     fmt.Println("小学生正在考试")
  34. }
  36. // 大学生考试
  37. type Graduate struct {
  38.     Student
  39. }
  41. // 保留 Graduate 特有方法
  42. func (p *Graduate) testing() {
  43.     fmt.Println("大学生正在考试")
  44. }
  46. func main() {
  47.     // 小学生
  48.     var pupil = &Pupil{}
  49.     pupil.Name = "tom"
  50.     pupil.Age = 6
  51.     pupil.testing()
  52.     pupil.SetScore(99.89)
  53.     pupil.ShowInfo()
  54.     pupil.DoHomework()
  56.     // 大学生
  58.     var graduate = &Graduate{}
  59.     graduate.Name = "bill"
  60.     graduate.Age = 19
  61.     graduate.testing()
  62.     graduate.SetScore(99.89)
  63.     graduate.ShowInfo()
  64.     pupil.DoHomework()
  65. }

继承使用细节

  1. 结构体可以使用嵌套匿名结构体的所有字段和方法（不论标识符是大写还是小写）
  2. 如果内部类型和外部类型有相同的字段或者方法，调用的时候采用就近原则，如果希望访问和设置匿名结构体的字段和方法，可以通过匿名结构体来区分
  3. 结构体嵌入了两个（或多个）匿名结构体，如果两个匿名结构体有相同的字段和方法（同时结构体本身没有同名的字段或方法），调用时，必须指定匿名结构体的名字，否则会报错。
  4. 如果一个 struct 嵌套了有名结构体，这种模式就是组合，如果时组合关系，那么在访问组合的结构体的字段或方法时，必须带上结构体的名字。
  5. 嵌套匿名结构体后，也可以在创建结构体变量（实例）时，直接指定各个匿名结构体字段的值。
  6. 多重继承 -> 嵌套多个结构体，同样可以访问字段和方法（为了代码简洁，嵌套关系清晰，建议不要使用多重继承）
  1. package main
  3. import (
  4.     "fmt"
  5. )
  7. type A struct {
  8.     Name string
  9.     Age  int
  10. }
  12. type B struct {
  13.     Name string
  14.     Age  int
  15. }
  17. type C struct {
  18.     A
  19.     B
  20.     // Name string
  21. }
  23. type D struct {
  24.     a A
  25. }
  27. type Goods struct {
  28.     Name  string
  29.     Price float64
  30. }
  31. type Brand struct {
  32.     Name string
  33.     addr string
  34. }
  36. // 多重继承
  37. type TV struct {
  38.     Goods
  39.     Brand
  40. }
  42. type TV2 struct {
  43.     *Goods
  44.     *Brand
  45. }
  47. type Monster struct {
  48.     Name string
  49.     Age  int
  50. }
  51. type E struct {
  52.     Monster
  53.     int
  54. }
  56. func main() {
  57.     var c C
  58.     // 如果C没有Name字段，而A和B有Name, 这时就必须通过指定匿名结构体名字来区分
  59.     // c.Name = "tom" // ambiguous selector c.Name 模糊的选择器
  60.     c.A.Name = "tom"
  61.     fmt.Println("c = ", c)
  63.     //嵌入 有名结构体 => 组合
  64.     // D 中存在有名结构体，在访问有名结构体的字段或者方法的时候，必须带上有名结构体的名字
  65.     var d D
  66.     d.a.Name = "xixi"
  67.     fmt.Println("d = ", d)
  69.     // 字面量形式创建组合实例
  70.     d2 := D{
  71.         a: A{
  72.             Name: "jerry",
  73.             Age:  2,
  74.         },
  75.     }
  76.     fmt.Println("d2 = ", d2)
  78.     // 创建 TV 实例
  79.     tv := TV{Goods{"小米电视", 200}, Brand{"xiaomi", "武汉"}}
  80.     fmt.Println("tv = ", tv)
  81.     tv02 := TV{
  82.         Goods{
  83.             Name:  "华为电视",
  84.             Price: 220,
  85.         },
  86.         Brand{
  87.             Name: "huawei",
  88.             addr: "深圳",
  89.         },
  90.     }
  91.     fmt.Println("tv02 = ", tv02)
  93.     // 内层结构是地址形式时，创建实例
  94.     tv03 := TV2{&Goods{"熊猫电视", 180}, &Brand{"熊猫", "中国"}}
  95.     // fmt.Println("tv03 = ", tv03) // {0xc0000040a8 0xc00004e3e0}
  96.     fmt.Println("tv03 = ", tv03.Goods, tv03.Brand)   // &{熊猫电视 180} &{熊猫 中国}
  97.     fmt.Println("tv03 = ", *tv03.Goods, *tv03.Brand) // {熊猫电视 180} {熊猫 中国}
  99.     // int 匿名字段是基本数据类型
  100.     var e E
  101.     e.Name = "牛牛"
  102.     e.Age = 3
  103.     e.int = 20
  104.     fmt.Println("e = ", e) // {{牛牛 3} 20}
  105. }