Python第十课，继承和多态

析构方法
当在某个作用域下面, 没有被使用[引用]的情况下, 解释器会自动的调用此函数, 来释放内存空间

class Person:
    def __init__(self, name):
        self.name = name
        print('构造方法调用')
        pass

    def eat(self):
        print('实例方法')
        pass

    def __del__(self):
        print('析构方法调用')
        pass
    pass

xm = Person('zhangsan')
xm.eat()

单继承
面向对象三大特效:

封装, 继承, 多态

封装: 把内容封装到某个地方, 便于后面使用
继承: 和现实生活当中的继承一样, 子可以继承父的内容[属性, 方法]

多继承
同名方法子类该怎么去调用, 可以通过 类.mro 查看继承顺序

class Animal:
    def eat(self):
        """
        吃
        :return:
        """
        print('吃')
        pass

    def drink(self):
        """
        喝
        :return:
        """
        print('喝')
        pass

class Felidae:

    def run(self):
        print('奔跑')
        pass
    pass

# 单继承
class Dog(Animal):  # 继承Animal 父类
    def wwj(self):
        print('小狗汪汪叫')
        pass

class Cat(Animal):  # 继承Animal 父类
    def mmj(self):
        print('小猫喵喵叫')
        pass

d1 = Dog()
d1.wwj()
d1.eat()  # 继承了父类的行为
c1 = Cat()
c1.mmj()
c1.drink()

# 多继承
class Tiger(Felidae,Animal):  # 老虎既是猫科也是动物

    def getNmae(self):
        print('老虎是百兽之王')
        pass
    pass

t1 = Tiger()
t1.getNmae()
t1.run()
t1.eat()
print(Tiger.__mro__) # 可以显示类的依次继承关系

重写父类方法

class Animal:
    def eat(self):
        print('吃')
        pass
    pass

class Dog(Animal):
    def eat(self):  # 重写父类的方法[方法覆盖]
        print('狗在吃骨头')
        pass
    pass

d1 = Dog()
d1.eat()

调用父类的方法

# 调用父类方法
class Dog:

    def __init__(self, name, color):
        self.name = name
        self.color = color

    def get_attr(self):
        print('狗的名字:%s,颜色是:%s' % (self.name, self.color))
        pass

    pass

class Kejiquan(Dog):

    def __init__(self, name, color):
        Dog.__init__(self, name, color)  # 手动调用
        # super().__init__(name,color)  # super是自动找到父类,进而调用方法,假设继承了多个父类, 那么会安装顺序逐个去找
        pass

    def bark(self):
        print('我也不知道')
        pass

    pass

k1 = Kejiquan('柯基', '红色')
k1.bark()
k1.get_attr()

多态
多态就是定义时和运行时类型不一致, 对于不同的子类(对象)有不同的行为表现

1. 继承: 多态必须发生在父类和子类之间
2. 重写: 子类重写父类的方法

Python不支持Java和C++这一类强类型语言多态写法, 但是原生多态, Python崇尚"鸭子类型", 利用Python伪代码实现多态

# 多态
class Animal:
    """
    父类
    """
    def say_who(self):
        print('我是一个动物...')
        pass
    pass

class Duck(Animal):
    """
    子类, 派生类
    """
    def say_who(self):
        """
        重写父类方法
        :return:
        """
        print('我是一只漂亮的鸭子')
        pass

    pass

def common(obj):  # 利用伪代码实现多态
    obj.say_who()

d1 = Duck()

common(d1)

类属性和实例属性
类属性: 类对象所拥有的属性

# 类属性和实例属性
class Person:
    name = '小明'  # 类属性

    def __init__(self, age):  # 实例属性 age
        self.age = age
        pass

    pass

lm = Person(18)  # 实例化

print(lm.name)  # 实例对象调用类属性
print(Person.name)  # 类对象调用类属性

类方法和静态方法
静态方法一般用于工具类 , 不会涉及到类方法和属性的操作

class Person:
    country = 'china'

    # 类方法 用 classmethod 来进行修饰
    @classmethod
    def get_country(cls):
        return cls.country  # 访问类属性
        pass

    # 静态方法
    @staticmethod
    def get_data():
        return Person.country
        pass
    pass

print(Person.get_country())  # 类调用类方法
Person.country = '英国'  # 类修改类属性
print(Person.get_country())

p = Person()
p.get_country()  # 实例化调用类方法
p.country = '中国'  #  实例化修改类属性
print(p.country)  # 实例化获取属性

print(Person.get_data()) # 通过类对象调用, 一般不会通过实例对象访问静态方法