Python面向对象-继承

面向对象继承

多个子类在概念上是一致的，所有就抽象出一个父类。
多个子类的共性，可以提取到父类中。
在实际的工作过程中：
从设计的角度看：先有子，再由父（抽取子类共有的）
从开发的角度看：先有父，再由子（方便调用）

• 方法继承

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