面向对象编程三大特征2
面向对象编程三大特性--继承
为什么需要继承：
一个小问题，看个学生考试系统的程序extends01.go，提出代码复用的问题：
代码：
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) SetScoure(score int) {
if score < 0 || score > 100 {
fmt.Println("您输入的成绩不正确")
}
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) SetScoure(score int) {
if score < 0 || score > 100 {
fmt.Println("您输入的成绩不正确")
}
p.Score = score
}
func (p *Graduate) testing() {
fmt.Println("大学生正在考试中...")
}
//代码冗余...高中生....
func main() {
var pupil = &Pupil{
Name : "tom",
Age : 10,
}
pupil.testing()
pupil.SetScoure(90)
pupil.ShowInfo()
var graudate = &Graduate{
Name : "mary",
Age : 20,
}
graudate.testing()
graudate.SetScoure(80)
graudate.ShowInfo()
}
对上面代码的小结：
1）Pupil 和 Graduate 两个结构体的字段和方法几乎一样，但是我们却写了两份几乎相同的代码，代码复用性不强。
2）出现代码冗余，而且代码不利于维护，同时也不利于功能的扩展。
3）解决方法--通过继承方式来解决
继承基本介绍和示意图：
继承可以解决代码复用，让我们的编程更加靠近人类思维。
当多个结构体存在相同的属性(字段) 和方法时，可以从这些结构体中抽象出结构体(比如刚才的Student)，在该结构体中定义这些相同的属性和方法。
其它的结构体不需要重新定义这些属性(字段)和方法，只需嵌套一个Student匿名结构体即可。
示意图：
也就是说：在Golang中，如果一个struct 嵌套了另一个匿名结构体，那么这个结构体可以直接访问匿名结构体的字段和方法，从而实现了继承特性。
嵌套匿名结构体的基本语法：
type Goods struct {
Name string
Price int
}
type Book struct {
Goods //这里就是嵌套匿名结构体Goods
Writer string
}
快速入门：
我们对extends01.go 改进，使用嵌套匿名结构体的方式来实现继承特性，请大家注意体会这样编程的好处
代码实现：
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) {
if score < 0 || score > 100 {
fmt.Println("您输入的成绩不正确")
}
stu.Score = score
}
//给 *Student 增加一个方法，那么Pupil 和 Graduate 都可以使用该方法
func (stu *Student) GetSum(n1 int, n2 int) int {
return n1 + n2
}
//小学生
type Pupil struct {
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 = 8
pupil.testing()
pupil.Student.SetScore(70)
pupil.Student.ShowInfo()
fmt.Println("res=",pupil.Student.GetSum(1,2))
graduate := &Graduate{}
graduate.Student.Name = "mary"
graduate.Student.Age = 20
graduate.testing()
graduate.Student.SetScore(90)
graduate.Student.ShowInfo()
fmt.Println("res2=", graduate.Student.GetSum(3,4))
}
继承的深入讨论：
1）结构体可以使用嵌套匿名结构体所有的字段和方法，即：首字母大写或者小写的字段、方法，都可以使用。
案例：
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)
}
func (a *A) hello2() {
fmt.Println("A hello", a.age)
}
type B struct {
A
}
func main() {
var b B
b.A.Name = "tom"
b.A.age = 19
b.A.Sayok()
b.A.hello()
b.A.hello2()
}
2）匿名结构体字段访问可以简化
案例：
func main() {
var b B
b.A.Name = "tom"
b.A.age = 19
b.A.Sayok()
b.A.hello()
b.A.hello2()
//上面的写法可以简化
b.Name = "smith"
b.age = 20
b.Sayok()
b.hello()
b.hello2()
}
对上面的代码小结：
（1）当我们直接通过b 访问字段或方法时，执行流程如下：比如 b.Name
（2）编译器会先看 b 对应的类型有没有Name，如果有，则直接调用 B 类型的 Name 字段
（3）如果没有就去看 B 中嵌入的匿名结构体 A 有没有声明 Name 字段，如果有就调用，如果没有继续查找...如果都找不到就报错。
3）当结构体和匿名结构体有相同的字段或方法时，编译器采用就近访问原则访问，如希望访问匿名结构体的字段和方法，可以通过匿名结构体名来区分。
案例：
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)
}
func (a *A) hello2() {
fmt.Println("A hello", a.age)
}
type B struct {
A
Name string
}
func main() {
var b B
b.Name = "jack"
b.A.Name = "soctt"
b.age = 100
b.Sayok()
b.hello()
}
4）结构体嵌入两个(或多个) 匿名结构体，如两个匿名结构体有相同的字段和方法(同时结构体本身没有同名的字段和方法)，在访问时，就必须明确指定匿名结构体名字，否则编译报错。
案例：
type A struct {
Name string
age int
}
type B struct {
Name string
score float64
}
type C struct {
A
B
}
func main() {
var c C
//如果c 没有Name字段，而A 和 B有Name字段，这时必须指定匿名结构体名字
//所以 c.Name 就会报编译错误，这个规则对方法也是一样的
//c.Name = "tom" //error
c.A.Name = "tom" //OK
fmt.Println(c) //{{tom 0}{ 0}}
}
5）如果一个struct嵌套了一个有名结构体，这种模式就是组合，如果是组合关系，那么在访问组合的结构体的字段或方法时，必须带上结构体的名字。
案例：
type A struct {
Name string
age int
}
type D struct {
a A //嵌套了有名结构体
}
func main() {
//如果D 中是一个有名结构体，则访问有名结构体的字段时，必须带上有名结构体的名字
//比如 d.a.Name
var d D
d.a.Name = "jack"
fmt.Println(d)
}
6）嵌套匿名结构体后，也可以在创建结构体变量(实例)时，直接指定各个匿名结构体字段的值。
案例：
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() {
tv1 := TV {Goods{"电视机001", 5000},Brand{"海尔", "山东青岛"},}
tv2 := TV {
Goods{"电视机002", 5000.99},
Brand{"西门子", "北京"},
}
tv3 := TV {
Goods{
Price : 4000,
Name : "电视机003",
},
Brand{
Name : "夏普",
Address : "上海",
},
}
fmt.Println(tv1)
fmt.Println(tv2)
fmt.Println(tv3)
tv4 := TV2 {&Goods{"电视机004", 7000}, &Brand{"创维", "河南"},}
tv5 := TV2 {
&Goods{
Name : "电视机005",
Price: 6000,
},
&Brand{
Name : "飞利浦",
Address : "荷兰",
},
}
fmt.Println(*tv4.Goods, *tv4.Brand)
fmt.Println(*tv5.Goods, *tv5.Brand)
}
