2021年12月9日

一、析构方法：__del__

class Animal:
    def __init__(self,name):
        self.name=name
        print('这是构造方法')
        pass
    def __del__(self):#主要应用是来操作对象的释放，一旦完毕对象便不能在使用
        print('当在某个作用域下边没有被使用引用下 解析会自动调用此函数 来释放内存内容')
        print('这是析构方法')
        print('%s对象被彻底清理了，内存空间也是放了'%self.name)
cat=Animal('咩咩')
del cat#手动删除对象，会指定__del__函数
print(cat.name)
#nput('程序等待中。。。。')
# print('*'*40)
# dog=Animal('柯基')

二、继承

oop三大特征：封装、继承、多态

（一）封装：

1、定义：

把内容封装在某个地方，便于后面使用

2、要求：

把内容封装到某个地方

从另一个地方去调用被封装的内容

3、解析：

使用初始化构造方法将内容封装在对象中，然后通过对象直接或self来获取被封装内容

（二）继承

1、定义：

子可继承父的内容【属性和行为】，相反不一定

2、特点

面向对象的继承来说，就是将多个类共有的方法提取到父类中，子类仅需继承父类而不必一一实现

这样极大提高效率，减少代码重复，便于拓展

（1）单继承

class Animal:
    def eat(self):
        print('吃饭了')
        pass
    def drink(self):
        pass
class Dog(Animal):#继承Animal，Dog就是子类
    def wwj(self):
        print('小狗汪汪叫')
class Cat(Animal):
    def mmj(self):
        print('小猫喵喵叫')
d1=Dog()
d1.eat()#具备了吃的行为，是继承了父类行为
d1.wwj()
c1=Cat()
c1.eat()
c1.mmj()

(2)多继承

class D:
    def eat(self):
        print('D.eat')
class C(D):
    def eat(self):
        print('C.eat')
class B(D):
    pass
class A(B,C):
    pass
a=A()
a.eat()

（3）重写

子类中，有一个和父类相同名字的方法，在子类中的方法会覆盖掉父类中同名的方法

class Dog:
    def __init__(self,name,color):
        self.name=name
        self.color=color
    def bark(self):
        print('汪汪叫')
class keji(Dog):
    def __init__(self,name,color):#重写父类的方法
        #针对这种需求，我们需要去调用父类的函数
        #Dog.__init__(self,name,color)#手动调用父类方法，执行完毕就具备name，color实例属性了
        super().__init__(name,color)#super()是自动找到父类，进而调动方法，假设继承多个父类，那会按顺序逐个去找，然后去调用
        #扩展其他属性
        self.height=40
        self.weight=20
    def __str__(self):
        return '{}的颜色是{}，身高{}cm，体重{}斤'.format(self.name,self.color,self.height,self.weight)
    def bark(self):
        Dog.bark(self)
        #super().bark()#调用父类方法
        print('叫神一样')#重写类方法
        print(self.name)
kj=keji('柯基','黄色')
kj.bark()
print(kj)

3、多态

（1）定义：

多种形态、状态，就是一种行为对不同子类【对象】有不同行为表现。

关注不是对象本身，而是如何使用

（2）实现多态前提：

多态必须发生在父类和子类之间

子类重写父类的方法

（3）好处

增加程序灵活性

增加程序拓展性

class Animal:
    def say(self):
        print('我是动物')
class Duck(Animal):
    '''
    子类【派生类】
    '''
    def say(self):
        '''
        重写父类的方法
        :return:
        '''
        print('我是一只鸭')
class Dog(Animal):
    def say(self):
        print('我是一条狗')
class Cat(Animal):
    def say(self):
        print('我是一只猫')
class Bird(Animal):
    '''
    新增鸟类，无需改变
    '''
    def say(self):
        print('我是一只黄鹂鸟')
class People():
    def say(self):
        print1('我是人类')
class student(People):
    def say(self):
        print('我是张明')
def commonInvoke(obj):
    '''
    统一调用
    :param obj: 对象实例
    :return:
    '''
    obj.say()
# duck1=Duck()
# duck1.say()
# dog1=Dog()
# dog1.say()
# cat1=Cat()
# cat1.say()
listObj=[Duck(),Dog(),Cat(),Bird(),student()]
for item in listObj:
    commonInvoke(item)

4、类方达

class People:
    country='China'
    #类方法，用classmethod来修饰
    @classmethod
    def get_country(cls):
        return cls.country#访问类属性
    @classmethod
    def change_country(cls,data):
        cls.country=data#修改类属性的值，在类方法中
    pass
print(People.get_country())#通过类对象去引用
print(People.country)
p=People()
print('实例对象访问%s'%p.get_country())
People.change_country('英国')
print(People.get_country())

5、静态方法

由于静态方法存放逻辑性代码，本身和剋以及实例对象没有交互，也就是说，在静态方法说，不会涉及到类中方法和属性的操作

这样数据资源能得到有效充分利用

class People:
    country='China'
    @classmethod
    def get_country(cls):
        return cls.country#访问类属性
    @classmethod
    def change_country(cls,data):
        cls.country=data#修改类属性的值，在类方法中
    @staticmethod
    def getData():
        return People.get_country()
    @staticmethod
    def add(x,y):
        return x+y
    pass
print(People.add(10,56))#带有参数静态方法
print(People.getData())
p=People
print(p.getData())#一般情况不会通过实例对象去访问静态方法