day08 Go中的面向对象

go 面向对象继承

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

package main

import "fmt"

// 父类结构体
type Person struct {
	name string
	age  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 Student
	s2.Person.name = "王五"
	s2.Person.age = 32
	s2.school = "北大"
	fmt.Println(s2)

	// 定义子类
	// 提升结构体字段：只有使用 `匿名字段` 才可以使用。即：Person在Student是一个匿名字段，Person中的name，age属性能直接被点出来
	var s3 Student
	s3.name = "赵六" // 提升字段，直接使用Person结构体中的name
	s3.age = 23    // 提升字段，直接使用Person结构体中的age
	s3.school = "科技大学"
	fmt.Println(s3)

}

go 面向对象中的方法

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

package main

import "fmt"

type Dog struct {
	name string
	age  int
}

// 定义 一个带结构体参数的函数方法。即：结构体能够调用该方法 , 也是面向对象中的方法
func (dog Dog) eat() {
	fmt.Println("Dog has func eat ")
}

// 对象属性
type Cat struct {
	name string
	age  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 main

import "fmt"

// 定义 父类
type Animal struct {
	name string
	age  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 {
	Animal
	color string
}

// 定义子类自己的方法
func (dog Dog1) bite() {
	fmt.Println(dog.name, "正在咬人。。。")

}

// 定义 Cat1 子类，并继承 Animal
type Cat1 struct {
	Animal
	color 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 main

import "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 AnimalInterface
	animal = dog
	realizePolymorphism(animal)

	// 总结：接口的实现 都拥有 多态特性，除了自己本身还是它对应的接口类型

}

小结 go 和 python对比面向对象

go 中的面向对象
			struct ： `类的定义 / 类中的类属性 / 对象属性`
				- 结构体继承 ： python类继承，继承不同的类的属性
				- 定义字段： python中类的实例化对象的 `属性`
			struct func： `类中的 类的实例化`
				- 结构体实现方法： python中类实例化对象的 方法
			interface ：  `类中的方法/对象方法`
				- 接口是一堆方法的集合： python中类定义一大堆类方法或者对象方法
			interface func `类的初始化，或者多态类的初始化`
				- 接口实现方法，传入一个接口对象。  python中类的实例化基类的实例化

python中的面向对象
			object 原类
			__init__ 属性
			- 方法
				- 静态方法
				- 类方法
				- 对象方法
			- 属性
				- 类属性
				- 对象属性
			- 魔方函数。即带下划线的函数
			- 封装
			- 多态
			- 继承



}