golang面向对象之继承

1、看一个问题，引出继承的必要性

  一个小问题，看一个学生考试系统的程序，提出代码复用的问题。

package main

import "fmt"

//编写一个学生考试系统
type Pupil struct {
	Name  string
	Age   int
	Score int
}

//显示他的成绩
func (p *Pupil) ShowInfo() {
	fmt.Printf("学生名=%v 年龄=%v 成绩=%v\n", p.Name, p.Age, p.Score)
}
func (p *Pupil) SetScore(score int) {
	p.Score = score
}
func (p *Pupil) testing() {
	fmt.Println("小学生正在考试中...")
}

//大学生
type Graduate struct {
	Name  string
	Age   int
	Score int
}

//显示他的成绩
func (p *Graduate) ShowInfo() {
	fmt.Printf("学生名=%v 年龄=%v 成绩=%v\n", p.Name, p.Age, p.Score)
}
func (p *Graduate) SetScore(score int) {
	p.Score = score
}
func (p *Graduate) testing() {
	fmt.Println("大学生正在考试中...")
}

//高中生...

func main() {
	var pupil = &Pupil{
		Name: "tom",
		Age:  10,
	}
	pupil.testing()
	pupil.SetScore(90)
	pupil.ShowInfo()

	var graduate = &Graduate{
		Name: "dry",
		Age:  10,
	}
	graduate.testing()
	graduate.SetScore(90)
	graduate.ShowInfo()
}

➢对上面代码的小结

1)Pupil 和Graduate两个结构体的字段和方法几乎,但是我们却写了相同的代码，代码复用性不强
2)出现代码冗余，而且代码不利于维护，同时也不利于功能的扩展。
3)解决方法通过继承方式来解决

2、继承的基本介绍

  继承可以解决代码复用，让我们的编程更加靠近人类思维。当多个结构体存在相同的属性(字段)和方法时,可以从这些结构体中抽象出结构体(比如刚才的Student)，在该结构体中定义这些相同的属性和方法。其它的结构体不需要重新定义这些属性(字段)和方法，只需嵌套一个Student匿名结构体即可。
  也就是说:在Golang中，如果-一个struct嵌套了另一个匿名结构体，那么这个结构体可以直接访问匿名结构体的字段和方法，从而实现了继承特性。

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

type Goods struct {
	Name  string
	Price float64
}

type Book struct {
	Goods  //这里就是嵌套匿名结构体的Goods
	Writer string
}

4、快速入门

  对上面的学生考试系统进行改进，使用匿名结构体实现继承和代码复用

package main

import "fmt"

type Student struct {
	Name  string
	Age   int
	Score int
}

//编写一个学生考试系统

//将Pupil和Graduate共有的方法也绑定到*Student
func (stu *Student) ShowInfo() {
	fmt.Printf("学生名=%v 年龄=%v 成绩=%v\n", stu.Name, stu.Age, stu.Score)
}

func (stu *Student) SetScore(score int) {
	stu.Score = score
}

//小学生
type Pupil struct {
	Student //嵌入了Student匿名结构体
}

//保留Pupil特有的方法
func (p *Pupil) testing() {
	fmt.Println("小学生正在考试中...")
}

//大学生
type Graduate struct {
	Student
}

//保留Graduate特有的方法
func (p *Graduate) testing() {
	fmt.Println("大学生正在考试中...")
}

func main() {
	//当对结构体嵌入了匿名结构体后使用方法会发生变化
	pupil := &Pupil{}
	pupil.Student.Name = "tom"
	pupil.Student.Age = 9
	pupil.testing()
	pupil.Student.SetScore(90)
	pupil.Student.ShowInfo()

	graduate := &Graduate{}
	graduate.Student.Name = "mary"
	graduate.Student.Age = 25
	graduate.testing()
	graduate.Student.SetScore(99)
	graduate.Student.ShowInfo()

}

5、继承深入

（1）结构体可以使用嵌套匿名结构体的所有字段和方法，包括首字母大写或小写的字段，方法都可以使用。案例

package main

import "fmt"

type A struct {
	Name string
	age  int
}

func (a *A) Sayok() {
	fmt.Println("A Sayok", a.Name)
}
func (a *A) hello() {
	fmt.Println("A hello", a.Name)
}

type B struct {
	A
}
func main() {
	var b B
	b.A.Name = "tom"
	b.A.age = 10
	b.A.Sayok()
	b.A.hello()

}

（2）匿名结构体字段访问可以简化。示例

var b B
	b.A.Name = "tom"
	b.A.age = 10
	b.A.Sayok()
	b.A.hello()
	
	//对上面的写法进行简化
	b.Name="mary"
	b.age=2
	b.Sayok()
	b.hello()

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

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

var b B
	//b.A.Name = "tom" 就明确指定访问A匿名结构体的字段name
	b.A.Name = "tom"
	b.A.age = 10
	b.A.Sayok()
	//b.A.hello()明确指定访问A匿名结构体的hello函数
	b.A.hello()

	//对上面的写法进行简化
	b.Name="mary" //这时就近原则，会访问B结构体的name字段
	b.age=2
	b.Sayok() //就近原则，会访问B结构体的say函数
	b.hello()

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

package main

import (
	"fmt"
)

type A struct {
	Name string
	age  int
}
type B struct {
	Name string
	Score float64
}
type C struct {
	A
	B
	//Name string
}
func main() {
	var c C
	//如果c没有Name字段，而A和B有Name,这时就必须通过指定匿名结构体名字来区分
	//所以c.Name就会编译错误，这个规则对方法同样适用
	c.A.Name="tom"
	//c.Name="mary"
	fmt.Println(c.Name)
}

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

type D struct {
	a A //有名结构体
}
func main() {
	//如果D中有一个有名结构体，则访问有名结构体字段时就必须带上有名结构体的名字
	var d D
	d.a.Name="tom"
}

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

package main

import "fmt"

type Goods struct {
	Name  string
	Price float64
}

type Brand struct {
	Name    string
	Address string
}
type TV struct {
	Goods
	Brand
}
type TV2 struct {
	*Goods
	*Brand
}

func main() {
	//嵌套匿名结构体后，也可以在创建结构体变量(实例)时， 直接指定各个匿名结构体字段的，值。
	tv := TV{Goods{"电视机2", 1444.1}, Brand{"海尔", "山东"}}
	tv2 := TV{
		Goods{
			Price: 5555.0,
			Name:  "电视机1",
		},
		Brand{
			Name:    "夏普",
			Address: "贵阳",
		},
	}
	fmt.Println("tv", tv)
	fmt.Println("tv2", tv2)

	tv3 := TV2{&Goods{"电视机2", 1444.1}, &Brand{"海尔", "山东"}}
	tv4 := TV2{
		&Goods{
			Price: 5555.0,
			Name:  "电视机1",
		},
		&Brand{
			Name:    "夏普",
			Address: "贵阳",
		},
	}
	fmt.Println("tv3", *tv3.Goods, *tv3.Brand)
	fmt.Println("tv4", *tv4.Goods, *tv4.Brand)
}

6、多重继承

通过一个案例来说明多重继承的使用

type Goods struct {
	Name  string
	Price float64
}

type Brand struct {
	Name    string
	Address string
}
type TV struct {
	Goods
	Brand
}

➢多重继承细节说明.
1)如嵌入的匿名结构体有相同的字段名或者方法名，则在访问时，需要通过匿名结构体类型名来区分。[ 案例演示]

	fmt.Println(tv.Goods.Name)
	fmt.Println(tv.Price)

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