2020-10-15

面向对象的三大特性

一、封装

• 类就像一个袋子，这就是一个封装
• 就是为了告诉你的协同开发者，我这个属性是是一个私有属性，只能内部访问，外部无法进入访问

class Student(object):

    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex
        
one = Student('plf',18,'男')

类里面别人不写set_name，就不能修改其属性，通过自己设置接口，可以有效规避脏数据

property装饰器

• 可以使实例调用get和set方法的时候，像查看属性一样
• 使用 @property 装饰器时，接口名不必与属性名相同
• 凡是赋值语句，就会触发set方法。获取属性值，会触发get方法

res = requests.get('xxx')
content = res.text    # text就使用了@property这个装饰器

二、继承

1. 继承是面向对象的三大特性之一；继承是指可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。
2. 通过继承创建的新类称为“子类”或“派生类”，被继承的类称为“基类”、“父类”或“超类”，继承的过程，就是从一般到特殊的过程。
3. 一般情况下，一个子类只能有一个基类，要实现多重继承，可以通过多级继承来实现。
4. isinstance（）判断是否为同一类
5. 子类不重写 init，实例化子类时，会自动调用父类定义的 init；
6. 如果重写了__init__ 时，实例化子类，就不会调用父类已经定义的 init
7. 如果重写了__init__ 时，要继承父类的构造方法，可以使用 super 关键字：

super(子类，self).__init__(参数1，参数2，....)

还有一种同样的写法：

父类名称.__init__(self,参数1，参数2，...)

方法重写

• 在子类中重写定义一个父类拥有的方法， 调用时使用子类中重写定义的方法
• 当我们调用一个对象的方法时，
  会优先去当前对象中寻找是否具有该方法，如果有则直接调用
  如果没有则去对象的父类中寻找，如果父类中有则直接调用父类中的方法
  如果还是没有则去父类中的父类中寻找，以此类推，直到找到object
  如果最初的类都没有则报错

多重继承

• 一个类可以继承多个类，形式如C(A,B)，通过就近原则调用两个父类当中的相同名字的方法，一般不推荐使用，会造成耦合的效果

解耦合
1.提高问题的解决效率
2.提高问题的解决效果
3.提高问题的解决速率
4.降低将来爆发问题的几率

三、多态

• 多态是面向对象的三大特性之一；
• 只关心对象的实例方法是否同名，不关心对象所属的类型；
• 对象所属的类之间，继承关系可有可无；
• 多态的好处可以增加代码的外部调用灵活度，让代码更加通用，兼容性比较强；并且不会影响到类的内部设计

多态的经典应用：
调用一个函数，传入不同参数，实现不同的功能；让具有不同功能的函数可以使用相同的函数名，这样就可以用一个函数名调用不同内容(功能)的函数。

1. 以一个经典应用场景举例：

class Duck(object):                                  # 鸭子类
    def fly(self):
        print("鸭子沿着地面飞起来了")

class Swan(object):                                  # 天鹅类
    def fly(self):
        print("天鹅在水面飞翔")

class Plane(object):                                 # 飞机类
    def fly(self):
        print("飞机在天上飞翔")

def fly(obj):                                        # 实现飞的功能函数
    obj.fly()

duck = Duck()
fly(duck)

swan = Swan()
fly(swan)

plane = Plane()
fly(plane)

===运行结果：===================================================================================
鸭子沿着地面飞起来了
天鹅在空中翱翔
飞机隆隆地起飞了

2. 多态的另一个经典应用场景：（对象所属的类之间有继承关系）

class gradapa(object):
    def __init__(self,money):
        self.money = money
    def p(self):
        print("这是祖父类")
 
class father(gradapa):
    def __init__(self,money,job):
        super().__init__(money)
        self.job = job
    def p(self):
        print("这是父类，我重写了祖父类的方法")
 
class mother(gradapa): 
    def __init__(self, money, job):
        super().__init__(money)
        self.job = job
 
    def p(self):
         print("this is mother,我重写了祖父类的方法")
         return 100
         
#定义一个函数，函数调用类中的p()方法
def func(obj):
    obj.p()
gradapa1 = gradapa(3000) 
father1 = father(2000,"工人")
mother1 = mother(1000,"老师")

fc(gradapa1)            
fc(father1)
print(fc(mother1))
===运行结果：===================================================================================
这是祖父类
这是父类，我重写了祖父类的方法
this is mother,我重写了祖父类的方法
100

另：
特殊方法

1. init 魔法方法
2. 初始化属性
3. 创建实例的时候就会调用这个方法
4. 特殊方法不需要我们调用，特殊方法会在特定时候自动调用