day08 Go中的面向对象

go 面向对象继承

• Go语言的继承：结构体的嵌套

package mainimport "fmt"// 父类结构体
type Person struct {name stringage  int
}// 子类结构体。 Student 使用了 匿名继承。表示 Student中拥有了 Person的所有字段
type Student struct {Person // 匿名字段，实现了继承school string
}func main() {// CTO  业务功能拆分，软件架构选型。/*go 中如何实现面向对象- 封装- 继承- 多态 宏观事物*/// 继承：父类通用，子类具体。 go语言中就是：结构体的嵌套// 定义 父类p1 := Person{name: "zhangsna", age: 19}fmt.Println(p1)// 定义 子类s1 := Student{Person: Person{"lisi",30,}, school: "清华"}fmt.Println(s1)// 定义子类var s2 Students2.Person.name = "王五"s2.Person.age = 32s2.school = "北大"fmt.Println(s2)// 定义子类// 提升结构体字段：只有使用 `匿名字段` 才可以使用。即：Person在Student是一个匿名字段，Person中的name，age属性能直接被点出来var s3 Students3.name = "赵六" // 提升字段，直接使用Person结构体中的names3.age = 23    // 提升字段，直接使用Person结构体中的ages3.school = "科技大学"fmt.Println(s3)}

go 面向对象中的方法

• 结构体能够调用该方法 , 也是面向对象中的方法

package mainimport "fmt"type Dog struct {name stringage  int
}// 定义 一个带结构体参数的函数方法。即：结构体能够调用该方法 , 也是面向对象中的方法
func (dog Dog) eat() {fmt.Println("Dog has func eat ")
}// 对象属性
type Cat struct {name stringage  int
}// 对象方法
func (cat Cat) eat() {fmt.Println("Cat has func eat ")
}
func (cat Cat) sleep() {fmt.Println("Cat has func sleep ")
}
func main() {/* go 语言中 面向对象的中的方法. 模拟成一个类 */dog := Dog{"金毛狗🐶", 30}dog.eat()cat := Cat{"布偶猫🐱", 21}cat.eat()cat.sleep()}

go 面向对象中的方法。【高阶使用】方法继承/重写

package mainimport "fmt"// 定义 父类
type Animal struct {name stringage  int
}// 定义父类的通用方法
func (a Animal) sleep() {fmt.Println(a.name, "正在睡觉。。。")
}
func (a Animal) eat() {fmt.Println(a.name, "正在吃饭。。。")}// 定义 Dog1 子类，并继承 Animal
type Dog1 struct {Animal
}
type Dog2 struct {Animalcolor string
}// 定义子类自己的方法
func (dog Dog1) bite() {fmt.Println(dog.name, "正在咬人。。。")}// 定义 Cat1 子类，并继承 Animal
type Cat1 struct {Animalcolor string // 定义子类自己的属性
}// Cat1 重写 父类的方法
func (cat Cat1) eat() {fmt.Println("Cat1 重写 父类的 eat 方法：", cat.name, "正在吃猫粮")
}func main() {golden_retriever := Dog1{Animal{name: "小金毛", age: 3}}ragdoll := Cat1{Animal: Animal{name: "布偶", age: 3}, color: "奶白色"}// 1. 子类使用父类的方法golden_retriever.eat()golden_retriever.sleep()// 2. 子类使用自己的方法fmt.Println("子类使用自己的方法:")golden_retriever.bite()// 3. 子类使用父类的属性fmt.Println("子类使用父类的属性:", ragdoll.name, ragdoll.age)// 4. 子类使用子类的属性fmt.Println("子类使用子类的属性:", ragdoll.color)}

go 面向对象中的多态

• go 中的多态，需要 go 的interface 接口来实现

package mainimport "fmt"// AnimalInterface 定义接口
type AnimalInterface interface {eat()sleep()
}type DogInterfaceStruct struct {name string
}
type CatInterfaceStruct struct {name string
}func (d DogInterfaceStruct) eat() {fmt.Println("多态狗狗🐶：", d.name, "正在吃")
}
func (d DogInterfaceStruct) sleep() {fmt.Println("多态狗狗🐶：", d.name, "正在睡觉")}func (c CatInterfaceStruct) eat() {fmt.Println("多态骚猫🐱：", c.name, "正在吃")}
func (c CatInterfaceStruct) sleep() {fmt.Println("多态骚猫🐱：", c.name, "正在睡觉")}func realizePolymorphism(animal AnimalInterface) {animal.eat()animal.eat()
}func main() {/*模糊类（结构体）/ 具体类（结构体）*/// go 中的多态。需要 go 中的interface 接口来实现// 多态：一个事物有多种形态cat := CatInterfaceStruct{name: "布偶猫"}cat.eat()cat.sleep()dog := DogInterfaceStruct{name: "小鸡毛"}dog.eat()dog.sleep()fmt.Println("------")// 定义一个类型 可以为 接口类型的变量，实际上所有实现类都可以赋值给这个对象。var animal AnimalInterfaceanimal = dogrealizePolymorphism(animal)// 总结：接口的实现 都拥有 多态特性，除了自己本身还是它对应的接口类型}