Day-14 继承和多态

子类可以拥有父类所有的非私有的属性和方法
子类可以重写父类的方法
父类不能使用子类的方法

子类可以直接添加其他方法，也可以重写父类方法
重写：重新实现从父类继承下来的方法
    a.完全重写
        直接重新实现父类的方法
    b.保留父类实现的功能，再添加新功能
        super().fun()
        super().父类方法
对象和类调用方法的过程：先看当前类是否
存在这个方法，如果没有，再从父类中找

class  Animal(object):
    number = 10
    def __init__(self):
        self.age = 0
        self.color = ''
    def eat(self):
        print('eat')
    @classmethod
    def get_number(cls):
        return  cls.number
class Dog(Animal):
    def look_after(self):
        print('s')
    # 完全重写父类中的方法
    # def eat(self):
    #   print('w')
    # super()保留父类方法再重写
    def eat(self):
        super().eat()
        print('s')
    @classmethod
    def get_number(cls):
        print(super().get_number())
if __name__ == '__main__':
    dog1 = Dog()
    dog1.eat()
    Dog.get_number()
    print(Animal.get_number())

对象属性的继承：是通过继承init方法来继承

class Person(object):
    def __init__(self,name,age):
        self.name = name
        self.age =age
class Staff(Person):
    # 添加对象属性，重写__init__方法
    # 如果要保留父类对象属性，用super()，
    # 去调用父类的__init__方法
    def __init__(self,name,age,salary):
        super().__init__(name,age)
        self.salary =salary

if __name__ == '__main__':

    emp = Staff('s',22,'90K')
    print(emp.name,emp.age,emp.salary)

s 22 90K

多态：子类继承父类的方法，可以对方法进行重写，
一个方法就有多种形态(多态的表现)
继承产生多态

重载：一个类中可以有多个名字相同的方法，就叫重载
Python中不支持方法的重载

运算符的重载:(重新定义运算符运算的过程)

、<、+、-
大于小于符号只需要重载其中的一个，另外一个的结果，
直接是重载的结果取反

class Student:
    def run(self, name):
        print('%s在跑' % name)
class Student2:
    def __init__(self, name='', age=0, height=0):
        self.name = name
        self.age = age
        self.height = height
    def __gt__(self, other):
        # 比较对象1>对象2的时候是比较的他们的height属性
        return self.height > other.height
        # return self.age > other.age
        # return id(self) > id(other)

    # 重载：<
    def __lt__(self, other):
        return self.age < other.age

    # 重载: +
    def __add__(self, other):
        return self.age + other.age

    # 重载: -
    def __sub__(self, other):
        return self.height - other.height


if __name__ == '__main__':
    stu = Student()
    stu.run('余婷')

    stu1 = Student2('aa', 18, height=170)
    stu2 = Student2('bb', 20, height=140)

    if stu1 > stu2:
        print('学生1大于学生2啊啊')

    if stu1 < stu2:
        print('学生1大于学生2')
    else:
        print('学生2小于学生1')

    print(stu1 + stu2)
    print(stu1-stu2)

    print(100+200)
    print('abc'+'abc')

python内存管理原理
内存中有两个特殊的区域：栈，堆

栈：栈中的内存是系统自动管理(内存的开辟和内存的释放)
作用域结束内存释放

堆：堆中的内存都是需要写程序去开辟和释放的
(Python中自动开辟和释放)

当一个对象没有引用的时候，对象对应的内存空间就会被释放
(引用计数机制)
引用：存储对象地址的变量