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

你可能感兴趣的:(Python面向对象-继承)