Golang如何体现面向对象三大特性之继承？

引出继承的必要性

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

package main

import(
	"fmt"
)
//小学生
type Pupil struct{
	name string
	age int 
	score int
}
//显示他的成绩
func (p *Pupil) ShowInfo(){
	fmt.Printf("姓名：%v,年龄: %d,成绩：%d\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,年龄: %d,成绩：%d\n",p.name,p.age,p.score)
}

func (p *Graduate) SetScore(score int){
	p.score = score
}

func (p *Graduate) testing(){
	fmt.Println("大学生正在考试中")
}
//中学生、高中生、研究生...?
func main(){
   p := Pupil{
	   name : "Casey",
	   age : 8,
   }
   p.testing()
   p.SetScore(100)
   p.ShowInfo()

   g := Graduate{
	   name : "Tom",
	   age : 20,
   }
   g.testing()
   g.SetScore(80)
   g.ShowInfo()
}

运行结果：

说明：

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

继承的基本介绍

基本介绍

继承可以解决代码复用，让编程更加靠近人类思维。
当多个结构体存在相同的属性（字段）和方法时，可以从这些结构体中抽象出结构体，在该结构体中定义这些相同的属性和方法。
其他结构体不需要重新定义这些属性和方法，只需嵌套一个Student匿名结构体即可。

示意图

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

快速入门案例

对上面案例进行改进：

package main

import(
	"fmt"
)
type Student struct{
	name string
	age int 
	score int
}
//小学生
type Pupil struct{
	Student
}

//大学生
type Graduate struct{
	Student
}

//显示成绩
func (this *Student) ShowInfo(){
	fmt.Printf("姓名：%v,年龄: %d,成绩：%d\n",this.name,this.age,this.score)
}

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

func (p *Pupil) testing(){
	fmt.Println("小学生正在考试中")
}

func (p *Graduate) testing(){
	fmt.Println("大学生正在考试中")
}
//中学生、高中生、研究生...?
func main(){
   p := Pupil{}
   p.Student.name = "Casey"
   p.Student.age = 10
   p.testing()
   p.Student.SetScore(99)
   p.Student.ShowInfo()

   g := Graduate{}
   g.Student.name = "Jerry"
   g.Student.age = 22
   g.testing()
   g.Student.SetScore(88)
   g.Student.ShowInfo()
}

运行结果：

继承的好处

• 代码的复用性提高了
• 代码的扩展性和维护性提高了

继承的注意事项

• 结构体可以使用嵌套匿名结构体所有的字段和方法。

package main

import(
	"fmt"
)

type A struct{
	name string
	age int
}

func (a *A) SayHello(){
   fmt.Printf("%v say hello",a.name)
}

type B struct{
	A
}

func main()  {
	var b B
	b.A.name = "Casey"
	b.A.age = 10
	b.A.SayHello()
}

运行结果：

• 匿名结构体字段访问可以简化

func main()  {
	var b B
	// b.A.name = "Casey"
	// b.A.age = 10
	// b.A.SayHello()
	//上面代码可以简化
	b.name = "Casey"
    b.age = 10
	b.SayHello()
	
}

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

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

package main

import(
	"fmt"
)

type A struct{
	name string
	age int
}

type B struct{
	name string
	age int
}
func (a *A) SayHello(){
   fmt.Printf("%v say hello\n",a.name)
}

type C struct{
	A
	B
	name string
}

func main()  {
	var c C
	
	c.name = "Casey"
	c.A.name = "Jerry"
	c.A.age = 10
	c.B.name = "Tom"
	c.B.age = 15
	c.SayHello()
	fmt.Println(c)
	
}

运行结果：

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

func main()  {

	c := C{
		name : "Casey",
		
		A : A{
			name : "Jerry",
			age : 30,
		},
		B : B{
			name : "Sally",
			age : 18,
		},
	}
	
	c.SayHello()
	fmt.Println(c)
	
}

多重继承

一个struct嵌套了多个匿名结构体，那么该结构体可以直接访问嵌套的匿名结构体的字段和方法，从而实现了多重继承。
案例：

为了保证代码的简洁性，建议尽量不使用多继承。

博主首页链接：https://blog.csdn.net/weixin_44736475
原创不易，希望大家多多支持
如果文章对你有帮助，记得一键三连哦！❤️❤️❤️