python笔记26 析构函数 继承(单,多继承) 父类的重写和调用

面向对象三大特征: 继承 多态 封装

class Animal:
    def __init__(self,name):
        self.name=name
        print('这是构造初始化的方法')
        pass
    def __del__(self):   ##释放资源
        print('当在某个作用域下面 没有被使用【引用】的情况下 解析器会自动的调用此函数 来释放内存空间')
        print('这是析构方法')
        print('程序被自动执行')
        pass
    pass

cat=Animal('喵呜')  #构造方法首先执行
input('程序等待中.....')
print('*'*40)
dog=Animal('汪汪')

class Animal:
    def __init__(self,name):
        self.name=name
        print('这是构造初始化的方法')
        pass
    def __del__(self):   ##释放资源
        # 主要应用就是来操作 对象的释放 一旦被释放 对象便不能再使用
        print('当在某个作用域下面 没有被使用【引用】的情况下 解析器会自动的调用此函数 来释放内存空间')
        print('这是析构方法')
        print('程序被自动执行')
        pass
    pass

cat=Animal('喵呜')  #构造方法首先执行
del cat  #手动去清理删除对象 会执行 del 函数  可以看到析构函数被执行 已被清理
input('程序等待中.....')
# print('*'*40)
# dog=Animal('汪汪')

cat=Animal('喵呜')  #构造方法首先执行
del cat  #手动去清理删除对象 会执行 del 函数  可以看到析构函数被执行 已被清理
print(cat.name)
input('程序等待中.....')
# print('*'*40)
# dog=Animal('汪汪')

在python中展现的面向对象的三大特征:
封装 继承 多态
封装:指的是吧内容封装到某个地方,便于后面的使用
需要:
把内容封装到某一个地方
从另外一处地方调用被封装的内容
对于封装来说,其实就是使用初始化构造方法__init)__将内容封装到对象中,然后通过对象直接或者self’间接来获取被封装的内容
继承:和 现实生活中的继承一样 子可以继承父亲的内容[属性和行为] (爸爸有的儿子都有,相反 儿子有的 爸爸不一定有)
所以对于面向对象的继承来说 其实就是将多个类共有的方法提取到父类中 子类仅需继承而不必一一去实现
这样就可以极大的提高效率 减少代码的重复编写 精简代码的层级结构 便于拓展

class Animal:
    def eat(self):
        '''
        吃
        :return:
        '''
        pass
    def drink(self):
        '''
        喝
        :return:
        '''
        pass
    pass
class Dog:
    def wwj(self):
        print('小狗汪汪叫')
    pass
class Cat:
    def mmj(self):
        print('小猫喵喵叫')
    pass

d1=Dog()
d1.eat()  #不具备吃的行为

class Animal:
    def eat(self):
        '''
        吃
        :return:
        '''
        print('粑粑吃吗')
        pass
    def drink(self):
        '''
        喝
        :return:
        '''
        pass
    pass
class Dog(Animal):  #继承animal父类 此时dog就是太子，子类
    def wwj(self):
        print('小狗汪汪叫')
    pass
class Cat(Animal):
    def mmj(self):
        print('小猫喵喵叫')
    pass

d1=Dog()
d1.eat()  #具备吃的行为

多继承

class shenxian:
    def fly(self):
        print('不就能飞，哼哼')
        pass
    pass
class Monkey:
    def eatpeach(self):
        print('猴子喜欢吃桃')
        pass
    pass
class Sunwukong(shenxian,Monkey):  #类
    pass
swk=Sunwukong()  #对象
swk.fly()        #行为
swk.eatpeach()

# 存在相同方法时，需要如何执行 应该调用哪一个
class D(object):
    def eat(self):
        print('该吃饭了，有点子饿')
        pass
    pass
class C(D):  #C中由此方法
    def eat(self):
        print('吃吃吃就知道吃')
        pass
    pass
class B(D):  #B中也没有
    pass
class A(B,C):   #A里面没有eat 去父类中查找
    pass

a=A()
a.eat()  #执行的是C中的内容
# 执行eat方法时，查找顺序为 去A中查找 A无　继续父类中查找　B无　去C中查找　
# 如果C类中无，则去D类中查找
# 顺序：　A－B—C—D

间接的级联继承

class Grandfather:
    def eat(self):
        print('大郎，吃药')
        pass
    pass
class Father(Grandfather):
    pass
class Son(Father):
    pass

son=Son()
print(Son.__mro__)   ##打印寻找顺序
son.eat()    #从grandfather中继承

一般情况下不超过三级

重写父类的方法

class Grandfather:
    def eat(self):
        print('大郎，吃药')
        pass
    pass
class Father(Grandfather):
    def eat(self):  #因为父类中已经存在这样的方法，在这里相当于方法覆盖了
        print('经常烫头吃海鲜')
    pass
class Son(Father):
    pass

son=Son()
print(Son.__mro__)   ##打印寻找顺序
son.eat()    #从grandfather中继承

重写父类方法

所谓重写,就是子类中,有一个和父类相同名字的方阿飞 在子类中的方法会覆盖掉父类中同名的方法
为什么要重写,父类的方法已经不满足子类的需要,那么子类可以重写父类或者完善父类的方法

class Dog:
    def __init__(self,name,color):
        self.name=name
        self.color=color
        pass
    def bark(self):
        print('汪汪')
        pass
    pass
class kjq(Dog):
    def __init__(self):   #重写父类的方法
        pass

    def bark(self):
        print('叫的和神一样')
        pass
    pass
kj=kjq()
kj.bark()

# 如何调用父类的内容

class Dog:
    def __init__(self,name,color):
        self.name=name
        self.color=color
        pass
    def bark(self):
        print('汪汪')
        pass
    pass
class kjq(Dog):
    def __init__(self,name,color):   #重写父类的方法 覆盖父类
        # 针对这种诉求，调用父类的构造函数
        Dog.__init__(self,name,color) #调用父类的方法 执行完毕就可以具备name和color
        pass

    def bark(self):
        print('叫的和神一样')
        pass
    pass
kj=kjq('柯基犬','红色')
kj.bark()

# 如何调用父类的内容

拓展父类不具备的属性

class Dog:
    def __init__(self,name,color):
        self.name=name
        self.color=color
        pass
    def bark(self):
        print('汪汪')
        pass
    pass
class kjq(Dog):
    def __init__(self,name,color):   #重写父类的方法
        # 针对这种诉求，调用父类的构造函数
        Dog.__init__(self,name,color) #调用父类的方法 执行完毕就可以具备name和color
        # 扩展其他的属性
        self.height=90
        self.weight=20
        pass
    def __str__(self):
        return '{}的颜色时{} 身高为{} 体重是{} '.format(self.name,self.color,self.height,self.weight)
    def bark(self):
        print('叫的和神一样')
        pass
    pass
kj=kjq('柯基犬','红色')
# kj.bark()
print(kj)

# 如何调用父类的内容

    Dog.__init__(self,name,color) #手动调用父类的方法 执行完毕就可以具备name和color
	super().__init__(name,color)  #自动调用父类的方法 假设继承了多个父类,那么会按照顺序逐个的去找 然后调用
def bark(self):
    super().bark()  #调用父类的方法
    print('叫的和神一样')
    pass