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__ 属性
- 方法
- 静态方法
- 类方法
- 对象方法
- 属性
- 类属性
- 对象属性
- 魔方函数。即带下划线的函数
- 封装
- 多态
- 继承
}
