面向对象：结构体实现
继承：匿名字段
type Tea struct {
name string
age int
}
type Stu struct {
Tea // 匿名字段，为Tea类型，继承了Tea
score int
name string
}
func main() {
s := Stu{Tea{"aaa", 111}, 111} // Stu对象，位置赋值
l := Stu{score: 111} // 指定score，关键字赋值
fmt.Println(s, l) // {{aaa 111} 111} {{ 0} 111}
s.Tea.name = "哈哈哈"
fmt.Println(s) // {{哈哈哈 111} 111}
s.age = 11111 // 修改父类Tea的age属性，子类Stu里没有这个属性
fmt.Println(s) // {{哈哈哈 11111} 111} Stu无age属性，修改的是父类Tea的age属性
}
优先使用子类的元素，没有就使用父类的元素。
s.name // 子类中的name属性
s.Tea.name // 父类中的name属性
指针类型匿名字段
type Tea struct {
name string
age int
}
type Stu struct {
Tea // 匿名字段，为Tea类型，继承了Tea
score int
}
type Stu2 struct {
*Tea // 指针类型元素
score int
}
// 值类型匿名变量是连续的地址，指针类型匿名变量是指向地址
func main() {
t := Stu2{score: 111}
fmt.Println(t) // {<nil> 111}
t.Tea = new(Tea)
t.Tea.name = "aaa"
fmt.Println(t, t.name, t.age) // {0xc000098440 111} aaa 0
(*t.Tea).name = "gogogo"
fmt.Println(t) // {0xc0000044c0 111}
t.Tea = &Tea{"aaa", 1} // {0xc000098460 111}
fmt.Println(t, t.name) // {0xc0000044e0 111} aaa
}
类方法
type Tea struct {
name string
age int
}
type Stu struct {
Tea // 匿名字段，为Tea类型，继承了Tea
score int
}
func (s Stu) jiao() { // 对象方法
fmt.Println("aaa")
}
func jiao() { // 普通方法
fmt.Println("aaa")
}
func (t Tea) tj() { // 对象方法
fmt.Println("bbb")
}
// 值类型匿名变量是连续的地址，指针类型匿名变量是指向地址
func main() {
s := Stu{Tea{"aaa", 11}, 100}
fmt.Println(s)
s.jiao()
s.tj()
jiao()
}
// 对象方法 和 普通方法 可以重名
// 属性可以继承，方法同样可以
类方法：值传递与指针传递
type Tea struct {
name string
age int
}
type Stu struct {
Tea // 匿名字段，为Tea类型，继承了Tea
score int
}
func (s Stu) jiao() { // 值传递
s.score = 11111
fmt.Println(s.score)
}
func (s *Stu) jiao2() { // 指针传递
s.score = 22222
fmt.Println(s.score)
}
func jiao() {
fmt.Println("aaa")
}
func (t Tea) tj() {
fmt.Println("bbb")
}
// 值类型匿名变量是连续的地址，指针类型匿名变量是指向地址
func main() {
s := Stu{Tea{"aaa", 11}, 100}
fmt.Println(s)
fmt.Println(s.score) // 100
s.jiao() // 11111
fmt.Println(s.score) //100
s.jiao2() // 22222
fmt.Println(s.score) // 22222
}
// 值传递是对象的副本，不影响原来的对象
// 指针传递是原对象本身，影响了对象本身
方法重写
子类重写了父类的方法
s.jiao // 子类的方法
s.Tea.jiao // 父类的方法
方法值与方法表达式
type Tea struct {
name string
age int
}
type Stu struct {
Tea // 匿名字段，为Tea类型，继承了Tea
score int
}
func (s Stu) jiao() { // 值传递
s.score = 11111
fmt.Println(s.score)
}
func (s *Stu) jiao2() { // 指针传递
s.score = 22222
fmt.Println(s.score)
}
// 值类型匿名变量是连续的地址，指针类型匿名变量是指向地址
func main() {
s := Stu{Tea{"aaa", 11}, 100}
p := s.jiao // 方法值：具体对象的方法
p() // s.jiao()
p1 := Stu.jiao // 方法表达式：类的方法，没有绑定对象
// p1() // 不行，需要传对象
// not enough arguments in call to p1
// have ()
// want (Stu)
p1(s) // 可以
// p2 := Stu.jiao2 // 不行，jiao2 是指针传递的方法
// invalid method expression Stu.jiao2 (needs pointer receiver: (*Stu).jiao2)
p2 := (*Stu).jiao2
// p2(s) // 不行，必须传指针对象
p2(&s)
p3 := (*Stu).jiao // jiao是值传递方法，也可以这样，传参也要地址
p3(&s)
}