面向对象编程03—封装、继承、重写、MRO、多态

九、封装

根据需求将属性和方法封装到一个抽象的类中，在使用的时候，只要按照自己的需求去调用，不必了解实现的细节。

封装有两方面的含义：

1、将数据（属性）和行为（方法）包装到类对象中。在方法内部对属性进行操作，在类对象的外部调用方法。这样，无需关心方法内部的具体实现细节，从而隔离了复杂度。
2、在类对象的内部通过访问控制把某些属性和方法隐藏起来，不允许对类对象的外部直接访问，而是在类对象的内部对外提供公开的接口方法以访问隐藏的信息。这样，就对隐藏的信息进行了保护。

class Student(object):
    def __init__(self):
        self.score=90

    def get_score(self):
        return self.__score

    def set_score(self,score):
        if 0<=score<=100:
           self.__score=score
        else:
            raise ValueError("成绩必须在0~100之间")

十、继承

继承是实现代码复用的重要手段

当几个类对象中有共同的属性和方法时，就可以把这些属性和方法抽象并提取到一个基类中，每个类对象特有的属性和方法还是在本类对象中定义，这样，只需要每个类对象都继承这个基类，就可以访问基类中的属性和方法了。继承基类的每个类对象被称为派生类。基类也被称为父类或超类，派生类也被称为子类。

单继承：子类只有一个直接父类
假设子类和父类分别为ChildClass和ParentClass，子类继承父类的语法格式为：

class ChildClass（ParentClass）：
    pass

多继承：子类有多个直接父类
假设子类是ChildClass，直接父类是ParentClass1，ParentClass2，…ParentClassn，子类继承父类的语法格式：

class ChildClass（ParentClass1，ParentClass2，......ParentClassn）
    pass

子类会继承所有父类（包括所有直接父类和所有间接父类）的所有属性和方法。

class ParentClassA(object):
    ca = 18
    def im(self):
        print("im()被调用了")
class PrentClassB(object):
    __pac =23
    def __pim(self):
        print("__pim()被调用了")
class PrentClassC(ParentClassA,PrentClassB):
    @classmethod
    def cm(cls):
        print("cm()被调用了")
class ParentClassD(object):  
    @classmethod
    def sm():
        print("sm()被调用了")        

子类可以添加父类中没有的属性和方法，

class BaseClass(object):
    ca_base = 5
    def im_base(self):
        print("im_base()被调用了")
class SubClass(BaseClass):
    ca_sub = 8
    def im_sub(self):
        print("im_sub()被调用了")
print(dir(SubClass))

十一、重写

1、如果子类对继承自父类的某个属性或方法不满意，可以在子类中对其进行重写从而提供自定义的实现，重写的方式：在子类中定义与父类中同名的属性和方法（包括装饰器）。
2、子类重写父类的属性或方法后，通过子类或其实例对象只能访问子类中重写的属性或方法，而无法再访问父类中被重写的方法。

父类中被重写的名为xxx的方法，在子类重写后的方法中可以通过super().xxx进行调用。

class PrentClass(object):
    ca = "ca(父类)"
    
    def __init__(self):
        print("__init__()被调用了（父类）")
        
    def im(self):
        print("im()被调用了（父类）")
        
    @classmethod
    def cm(cls):
        print("cm()被调离了（父类）")
        
class ChildClass(object):
    ca = "ca(子类)"
    
    def __init__(self):
        super().__init__()
        print("__init__()被调用了（子类）")
        
    def im(self):
        super().im()
        print("im()被调用了（子类）")
        
    @classmethod
    def cm(cls):
        super().cm()
        print("cm()被调离了（子类）")        

十二、MRO（方法解析顺序）

MRO指的是对于一棵类继承树，当调用最底层类对象所对应实例对象的方法时，python解释器在类继承树上搜索方法的顺序。
对于一棵类继承树，可以调用最底层类对象的方法mro或访问最底层类对象的特殊属性__mro__,获得这颗类继承树的MRO.

class A(object):
    def f(self):
        print("A.f")
class B(A):
    def f(self):
        print("B.f")
class C(A):
    def f(self):
        print("C.f")
class D(B,C):
    def f(self):
        print("D.f")

在子类重写后的方法中通过super（）调用父类中被重写的方法时，在父类中搜索方法的顺序基于以该子类为最底层类对象的类继承树MRO。
如果想调用指定父类中被重写的方法，可以给super（）传入两个实参：super(a_type,abj),其中，obj所对应类对象的MRO中，a_type后面那个类对象。

十三、多态

——在不考虑对象类型的情况下使用的对象

class ParentClass(object):
    def do_sth(self):
         print("do_sth() in ParentClass")
         
class ChildClass1(ParentClass):
    def do_sth(self):
        print("do_sth() in ChildClass1")

class ChildClass2(ParentClass):
    def do_sth(self):
          print("do_sth() in ChildClass2")    
 
 def f(parent):
     parent.do_sth()

简单地说，多态就是“具有多种形态”，它指的是：即便不知道一个变量所引用的对象到底是什么类型，仍然可以通过这个变量调用方法，在运行过程中根据变量所引用对象的类型，动态地决定调用哪个对象中的方法。

如果子类中不存在指定名称的方法，回到父类中去查找，如果在父类中找到了，则调用父类中的方法。

class ChildClass3(ParentClass):
    pass

鸭子类型：
如果一只生物走起来像鸭子，游起泳来像鸭子，叫起来也像鸭子，那么它就可以被当做鸭子。
也就是说，它不关注对象的类型，而是关注对象具有的行为。

注：嵩天老师《python及其应用》笔记