面向对象继承
多个子类在概念上是一致的，所有就抽象出一个父类。
多个子类的共性，可以提取到父类中。
在实际的工作过程中：
从设计的角度看：先有子，再由父（抽取子类共有的）
从开发的角度看：先有父，再由子（方便调用）
- 方法继承
class Animal:
def say(self):
print("动物都会叫")
class Dog(Animal):
def run(self):
print("狗会跑")
class Bird(Animal):
def fly(self):
print("鸟会飞")
dog = Dog()
bird = Bird()
animal = Animal()
dog.run()
dog.say()
bird.fly()
bird.say()
# isinstance 只能判断对象
print(isinstance(dog, Animal))
# issubclass 只能判断类
print(issubclass(Dog, Animal))
- 父级变量继承
class Person:
def __init__(self, name):
self.name = name
class Student(Person):
def __init__(self, name, score):
super().__init__(name)
self.score = score
p01 = Person("kkkk")
print(p01.name)
s01 = Student("wangyi", 100)
print(s01.name)
print(s01.score)
设计原则
- 单一职责（一个类的定义）
一个类只做一件事情 - 开-闭原则：只能对原有代码进行增加（扩展），不能对原有代码进行修改。
- 依赖倒置原则：客户端代码（调用的类）从依赖具体类改为依赖抽象类，抽象是稳定的，实现是多变的。
- 组合复用原则：如果仅仅为了代码复用优先选择组合复用，而非继承。
- 里氏替换原则 ：（继承后的重写）
父类出现的地方可以被子类替换，替换后保存原有功能。
子类要拥有父类的所有功能。
子类在重写父类方法时，尽可能选择扩展重写
开-闭原则
组合复用原则
"""
练习16：设计原则 - “开-闭” 总设计原则
"""
# 违反了“开-闭”原则
# 如果增加了“火车”，需要增加“火车”类，但是“Person”类修改了
class Person:
def __init__(self, name):
self.name = name
def go_to(self, vehicle, pos):
if type(vehicle) == Car:
res = self.name + vehicle.run(pos)
elif type(vehicle) == AirPlan:
res = self.name + vehicle.fly(pos)
print(res)
class Car:
def run(self, pos):
return "开车去" + pos
class AirPlan:
def fly(self, pos):
return "坐飞机去" + pos
p01 = Person("老张")
c01 = Car()
p01.go_to(c01, "东北")
a01 = AirPlan()
p01.go_to(a01, "东北")
依赖倒置(依赖抽象)
客户端代码（调用的类）从依赖具体类改为依赖抽象类
抽象是稳定的，实现是多变的。采用依赖倒置来处理上面的问题:
依赖倒置
"""
练习16：设计原则 - 依赖倒置（依赖抽象）
"""
# 违反了“开-闭”原则
# 如果增加了“火车”，需要增加“火车”类，但是“Person”类修改了
class Person:
def __init__(self, name):
self.name = name
def go_to(self, vehicle, pos):
# 调用的是父类“交通工具类”的运输方法
# 执行的是子类的实现方法
# 多态：父类的一种动作或行为，在不同子类上有不同的实现称为“多态”
res = self.name + vehicle.transport(pos)
print(res)
class Vehicle:
"""
“交通工具”父类
"""
def transport(self, pos):
# 继承 : 隔离子类变化，将子类的共性提取到父类中
# 具体实现由子类处理(重写)
pass
class Car(Vehicle):
def transport(self, pos):
return "开车去" + pos
class AirPlan(Vehicle):
def transport(self, pos):
return "坐飞机去" + pos
p01 = Person("老张")
c01 = Car()
p01.go_to(c01, "东北")
a01 = AirPlan()
p01.go_to(a01, "东北")
- 多态继承父类规定要求
"""
练习16：设计原则 - 依赖倒置（依赖抽象）
"""
class Grenade:
"""
手雷
"""
def __init__(self, atk):
self.atk = atk
def damage(self, damageable):
"""
手雷伤害了什么
:param damageable: 物品父类
:return:
"""
# 如果传入的不是子类，则报错
if not isinstance(damageable, Damageable):
raise ValueError("不是 Damageable 的子类")
print("手雷炸了")
damageable.damage(self.atk)
class Damageable:
def damage(self, value):
raise NotImplementedError()
class Player(Damageable):
def __init__(self, hp):
self.hp = hp
def damage(self, value):
print("玩家受伤了")
class Enemy(Damageable):
def __init__(self, hp):
self.hp = hp
def damage(self, value):
print("敌人受伤了")
grenade = Grenade(50)
p01 = Player(1000)
grenade.damage(p01)
c01 = Enemy(200)
grenade.damage(c01)
类与类之间的关系
- 泛化 (继承)：
--- 父类与子类的关系，概念的复用，耦合度高 - 关联：
--- 部分与整体的关系，功能复用，变化影响一个“类”
--- A 与 B 关联， 意味着 B 是 A 的一部分 (例如：是 A 的成员变量) -
依赖： 合作关系，一种相对松散的协作关系，变化影响一个“方法”
--- B 类型作为 A 类型某个方法的一个“参数”
类与类之间的关系
类内置函数
"""
练习22：类内置函数
"""
class Enemy:
def __init__(self, name):
self.name = name
# 对人友好
def __str__(self):
return "敌人名称：" + self.name
# 克隆一个对象
def __repr__(self):
return "Enemy('%s')" % self.name
enemy = Enemy('mmmm')
# before __str__ => <__main__.Enemy object at 0x000001C19BCFE8E0>
# after __str__ => 敌人名称：mmmm
print(enemy)
enemy02 = eval(repr(enemy))
enemy02.name = 'wangcai'
print(enemy.name) # mmmm
print(enemy02.name) # wangcai
类运算符重载
"""
练习22：类运算符重载
"""
class Vector1:
def __init__(self, x):
self.x = x
def __add__(self, other):
self.x += other
return self.x
def __str__(self):
return "1维向量：%d" % self.x
vector01 = Vector1(10)
print(vector01 + 2) # 12
多个父类执行顺序
例子：
错误的设计
正确设计01
正确设计02
