Golang——面向对象之继承（匿名字段）、指针类型匿名字段、多重继承

面向对象：

面向过程 ：是一种以过程为中心的编程思想，强调的是步骤、过程、每一步都是自己实现的面向对象 ：是一种以对象为中心的编程思想，强调的是去掉步骤、过程、通过指挥对象实现具体的功能

总结：想吃饭自己做就是面向过程，点外卖就是面向对象，我们不关心具体饭是怎么做的，我们只要使用美团点外面就可以了，可以将复杂的问题简单化

面向对象的特征：

封装继承多态 类：

类是一系列事务的统称，同类事务必定有相同的特征

类是对现实生活中一类具有共同属性和行为的事物的抽象类是对象的数据类型，类是具有相同属性和行为的一组对象的集合类是通过属性和方法来描述的类就是对现实事物的一种描述

类的组成：

属性：指事物的特征，例如：手机事物（品牌，价格，尺寸）
行为：指事物能执行的 *** 作，例如：手机事物（打电话，发短信）

类和对象的关系：

类：类是对现实生活中一类具有共同属性和行为的事物的抽象
对象：是能够看得到摸的着的真实存在的实体
简单理解：类是对象的描述，对象是类的实体

继承：

继承是一种类之间的关系，描述一个类从另一个类获取成员信息的关系，父类提供成员信息，子类获取成员信息继承父类的属性和行为，使得子类对象可以直接具有与父类相同的属性、相同的行为。子类可以直接访问父类中的非私有的属性和行为。继承是多态的前提，如果没有继承，就没有多态。在Golang中没有类似其它语言的继承语法，而是使用匿名字段实现继承的概念

好处：

1.提高代码的复用性(相同的代码不需要重复的写，只需要提取到父类中，子类可以直接使用)
2.提高代码的维护性

弊端：

耦合性（代码与代码之间存在关联就是耦合）降低代码的灵活性（继承了以后子类必须拥有父类的非私有属性和方法，子类会被约束）

就近原则：

在子类方法中访问一个变量，采用的是就近原则，先看自己有没有，没有就找爸爸要

整个流程是这样：
子类局部范围找
子类成员范围找
父类成员范围找
如果都没有就去父亲的父亲找

使用场景：

类与类之间存在相同（共性）的内容，就可以使用继承优化代码。
比如iPhone是一个手机品牌，huawei是一个手机品牌，Samsung也是一个手机品牌，但都有一个共性就是手机，所以就都可以继承手机类

继承格式：

在自类的结构体中添加父类的名称

继承初始化格式：

// 全部初始化
变量名 := 子类名称{父类名称{父类成员1的值,父类成员2的值},子类成员1的值,子类成员2的值}

// 部分初始化
变量名 := 子类名称{父类名称:父类名称{父类成员:值},子类成员:值}

获取成员的值：

// 获取子类的成员
子类名.子类成员

// 获取父类的成员2种格式都可以，第一种方式是，会先去子类中找成员，子类没有就会去父类找
子类名.父类成员
子类名.父类名.父类成员

修改成员的值：

子类变量名.成员名 = 成员值

演示：

func main() {
	//全部初始化
	stu := Student{Person{001, "itzhuzhu", 24}, 100}
	//部分初始化
	stu2 := Student{Person: Person{id: 001}, score: 100}
	stu.age = 23
	fmt.Println(stu)
	fmt.Println(stu2)
	fmt.Println(stu2.score)
	fmt.Println(stu2.Person.id)
}

/*
	将公共的属性抽取到一个类中，然后需要的时候就继承
 **/
type Person struct {
	id   int
	name string
	age  int
}

type Student struct {
	Person // 匿名字段，只有类型没有名字
	score  float64
}

type Teacher struct {
	Person
	salary float64
}

指针类型匿名字段：

指针类型就是替换匿名字段的，格式就是加个*

演示：

func main() {
	//全部初始化
	stu := Student{&Person{001, "itzhuzhu", 24}, 100}
	//部分初始化
	stu2 := Student{Person: &Person{id: 001}, score: 100}
	stu.age = 23
	fmt.Println(stu)
	fmt.Println(stu2)
	fmt.Println(stu2.score)
	fmt.Println(stu2.Person.id)
}


type Person struct {
	id   int
	name string
	age  int
}

type Student struct {
	*Person
	score float64
}

type Teacher struct {
	*Person
	salary float64
}

多重继承：

多重继承后，子类可以直接使用.父类的父类成员
多重继承和java的是一样的，但是这里全部初始化，试了一下好像不太行，先记录一下，只能指定初始化

演示：

func main() {
	stu := Student{score: 100}
	stu.id = 001
	stu.name = "itzhuzhu"
	stu.age = 24
	fmt.Println(stu.score)
	fmt.Println(stu.Person.name)
	fmt.Println(stu.Person.age)
	fmt.Println(stu.Person.Object.id)
}

type Object struct {
	id int
}
type Person struct {
	Object
	name string
	age  int
}

type Student struct {
	Person
	score float64
}

type Teacher struct {
	Person
	salary float64
}