14-面向对象3 & 内存管理

一、重写

1. 完全重写

• 重新实现从父类继承下来的方法，重写后，子类再调用这个方法的时候，就调用子类的
  
  

2. 保留加创新

• 保留父类实现的功能，再添加新的功能
  
  

3. 对象和类调用方法的过程

• 看当前类是否存在这个方法
• 再看父类有没有这个方法
• 再看父类的父类有没有这个方法
• 直到找到基类（object）
  
  

综合举例：

class Animal(object):
    """动物类"""
    def __init__(self):
        self.age = 0
        self.color = ''

    def eat(self):
        print('吃东西')

    def shout(self):
        print('叫唤')

    @classmethod
    def get_number(cls):
        return 100


class Dog(Animal):
    """狗类"""
    def look_after(self):
        print('看家')

    #  重写父类的shout
    def shout(self):
        print('汪汪汪~')

    # 重写父类eat方法
    def eat(self):
        # 保留父类eat的功能
        super().eat()
        print('吃骨头')

    @classmethod
    def get_number(cls):
        # 保留父类的类方法的功能的时候，还是super().类方法
        print(super().get_number())


if __name__ == '__main__':
    dog = Dog()
    dog.age = 3
    print(dog.color)
    dog.shout()
    dog.look_after()
    dog.eat()

    an = Animal()
    # 继承后，父类不能使用在子类中添加的属性和方法
    # an.look_after()
    an.eat()

    Dog.get_number()

二、添加属性

1. 给当前类添加对象属性

• 重写 init 方法
• 注意：如果要保留父类的对象属性，主要使用super（）去调用父类的init方法

2. 多态

多态

同一个失误有多种形态

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

• 综合举例

class Person(object):
    """人类"""
    def __init__(self, name, age=0, sex=''):
        self.name = name
        self.age = age
        self.sex = sex

    def eat(self):
        print('人在吃饭')


class Staff(Person):
    # init方法的参数：保证在创建对象的时候就可以给某些属性赋值
    def __init__(self, name='', age=0, salary=0):
        super().__init__(name, age)
        self.salary = salary

    def eat(self):
        print('员工在吃饭')

class Scientist(Person):
    def eat(self):
        print('科学家在吃饭')


if __name__ == '__main__':
    p1 = Person('李四',sex='女')
    p1.eat()

    s1 = Staff(age=18)
    s1.sex = '男'
    print(s1.name)
    s1.salary = 10000
    print(s1.salary)
    s1.eat()


# 练习：
"""
声明人类，有属性，名字、年龄、性别、身高
要求创建人的对象的时候可以给名字、性别、年龄赋初值

再创建学生类继承自人类，拥有人类的所有的属性，再添加学号、成绩、电话属性
要求创建学生对象的时候可以给名字、年龄和电话赋初值
"""
class Person2:
    """人类"""
    a = 10

    def __init__(self, ，, sex, age):
        self.name = name
        self.age = age
        self.sex = sex
        self.height = 0


class Student(Person2):
    """学生类"""
    b = 100

    def __init__(self, name='', age=0, tel='00'):
        super().__init__(name, age=age, sex='女')
        self.study_id = '00'
        self.score = 0
        self.tel = tel


stu = Student('李四')
stu.sex = '男'
print(stu.age)

p1 = Person2('张三', '男', 18)

3. 重载

• 一个类中可以有多个名字相同的方法，但是参数不一样，就叫重载。但是python中不支持。

三、python中的内存管理

• 栈

栈中的内存是系统自动管理的 —— 作用域结束，内存就释放

• 堆

堆中的内存都需要写代码去开辟和释放

• 原理

看一个对象有几个引用，当一个对象没有一个引用的时候，对象对应的内存空间就会被释放

• 引用

存储对象地址的变量

四、包

• 对一个功能的封装 —— 用函数
• 对多个功能的封装 —— 模块和类
• 对多个数据的封装 —— 类、字典
• 对多个类进行封装 —— 模块
• 对多个模块进行封装 —— 包

易竹小居士.jpg