PYTHON学习笔记（七）-- 面向对象（中）

1. 析构函数
2. 继承
3. 多态
4. 类属性和实例属性
5. 类方法和静态方法

1.析构函数
当一个对象被删除或销毁时，python解释器会默认调用析构方法，也就是__del__()方法。
定义–在类中像其他魔术方法一样定义
当类有析构对象时，程序脚本结束时，自动调用del，自动清理新建出来的对象
析构函数一般用于资源回收，回收内存等资源

def __del__(self):
		print("del方法被调用，函数被销毁")

#主动调用del删除对象，不需要等程序结束
del 对象名

2.继承
对于一些共有的方法，可以提取到父类中，子类仅需要继承父类而不需要一一事项
极大的提高效率，减少代码的重复编写

	class Animal:
    def run(self):
        print('跑起来')
        pass
    def eat(self):
        pass

#继承--在括号内写入要继承的类
class dog(Animal):#继承了Animal弗雷，此时dog作为子类就可以调用animal的方法
    def wwj(self):
        print('汪汪叫')
        pass
class cat:
    def mmj(self):
        print('喵喵叫')
        pass

di = dog()
di.run()#具备了吃的行为 继承了父类的行为

多继承：

class Animal:
    def run(self):
        print('跑起来')
        pass
    def eat(self):
        print('恰饭')
        pass

class life:
    def breath(self):
        print('呼吸')
        pass
    def eat(self):
        print('恰东西')
        pass

#继承--在括号内写入要继承的类
#多继承--在括号内写多个类，并用逗号分隔
class dog(Animal,life):#继承了Animal弗雷，此时dog作为子类就可以调用animal的方法
    def wwj(self):
        print('汪汪叫')
        pass
class cat(Animal):
    def mmj(self):
        print('喵喵叫')
        pass
    def eat(self):#子类也可以重写父类的方法
        print('吃猫粮')
        pass

di = dog()
di.run()#具备了吃的行为 继承了父类的行为
di.breath()

#Q 当多个父类中拥有多个相同方法时，要调用哪一个呢？？
di.eat()#恰饭  如果有相同父类方法，则调用以第一个为准，及括号中拥有相同方法的第一个
#方法查询顺序，先在本方法查找，然后在父类中按从左到右查找，随后再找父类的父类，一直向上找，没有则报错

print(dog.__mro__)#用该方法可以打印类的继承顺序

重构

#父类又称为基类，子类又称为派生类

#子类重写父类的方法
m1 = cat();
m1.eat()


#如果父类有init方法，且子类没有，那么继承时也要传递所需要的特定参数,除非子类重写方法
#同时子类也可以使用父类的实例属性
class quan:
    def __init__(self,name,color):
        self.name = name
        self.color = color
        pass
    def brek(self):
        print('brek')
        pass
class keji(quan):
    def __init__(self,name,color):
        quan.__init__(self,name,color)#手动调用父类的方法
        #调用父类init方法，也需要传入相同参数，定义后就可以使用父类的对应属性
        #super.__init__(name,color)#和上方效果一样,自动找父类，进而调用方法
        pass
    def brek(self):
        super().brek()#自动找到父类方法
        print('kejibrek')#重写方法
        pass
    def __str__(self):
        return '%s的%s'%(self.color,self.name)

kj = keji('柯基','白色')
print(kj)
kj.brek()

3.多态
同一种行为，对于不同的子类【对象】有不同的行为表现
要实现多条，必须实现两个前提：
1.继承：多态必须发生在父类和子类之间
2.重写：子类重写父类的方法

定义时的类型和运行时的类型不一样，此时就称为多态

class Animal:

    def say(self):
        print('我是一个动物...')
        pass
    pass

class Duck(Animal):
    def say(self):#子类有和父类相同的方法时，即为重写父类方法
        print('我是一只鸭子')
        pass
    pass

duck1 = Duck();
duck1.say()

#定义统一调用方法，多个对象分别调用对应方法
def commonInvoke(obj):
    obj.say()

listObh = [Animal(),Duck()]
for item in listObh:
    #循环调用函数
    commonInvoke(item)

4.类属性和实例属性

类属性：类中直接定义
实例属性：类中的方法中定义的，self的

修改类属性：通过类对象修改
类名.类属性 = 新数据

5.类方法和静态方法
类方法：
类对象所拥有的方法，需要用@classmethod来标识为类方法，对于类方法，第一个参数必须为类对象，一般用cls作为第一个参数，类方法可以通过类对象，实例对象调用

#类方法
class People:
    country='china'
    @classmethod#定义为类方法
    def get_contry(cls):
        return cls.country#访问类属性
        pass
    @classmethod
    def change_contry(cls,data):
        cls.country = data#修改类属性的值
        pass
    pass

print(People.get_contry())#通过类对象直接调用类方法
p1 = People()
print(p1.get_contry())#通过实例对象访问
p1.change_contry('英国')
print(p1.get_contry())#通过类方法修改类属性
print(People.get_contry())

静态方法：
需要用@staticmethod来表示静态方法，不需要任何参数

一般情况下，不会通过实例对象访问静态方法

为什么使用静态方法？
由于静态方法主要存放逻辑性的代码，本身和类及对象没有交互，也就是说，在静态方法中，不会涉及到类中方法和属性的操作

优点：数据资源能够得到有效的利用

#静态方法

    @staticmethod
    def getData():
        return People.country
        pass
    pass
    #访问静态方法
print(p1.getData())
print(People.getData())

1.类方法的第一个参数是类对象cls,进而去引用类对象的属性和方法，要用@classmethod休息
2.实例方法的第一个参数是self，通过self可以去引用类属性或实例属性，若存在同名实例属性和类属性，实例属性优先级最高
3.静态方法不需要定义额外的参数，若需要引用属性，可以通过类对象或实例对象去引用即可