面向对象编程(三)

面向对象编程三

(是有属性在累的外部不可以使用，需要改名，在类的内部可以直接使用)

封装

关于封装

• 封装是面向对象编程的三大特征之一
• 根据需求将属性和方法封装到一个抽象的类中
• 在使用的时候，只要按照自己的需求去调节，不必了解实现的细节

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

继承：（提高代码复用程度，避免数据冗余）( 调用类对象的方法时时不用写参数）

关于继承

• 当几个类对象中有共同的属性和方法时，就可以把这些属性和方法抽象并提取到一个基类中，每个类对象特有的属性和方法还是在本类对象中定义，这样，只需要让每个类对象都继承这个基类，就可以访问基类中的属性和方法了。继承基类的每个对象呗称为派生类。基类也被称为父类或超类，派生类也被称为子类。
• python中所有类对象都继承自一个统一的基类：object，这就是为什么我们在定义类对象时要在类名后面添加（object）
• 除了封装，继承也是面向对象编程的散大特征之一。继承是实现代码复用的重要手段

继承的类型

1、单继承：子类只有一个直接父亲是称为单继承
假设子类和父亲分别为ChildClass和FatherClass，子类继承父亲的语法格式为：

>>>class  ChildClass(ParentClass):
                   pass

>>>class ParentClassA(object):          #父类
              cm = 66
              def me(self):
                    print("被调用了“）
>>>class ChildClass(ParentClassA):        #子类，只有一个直接父类
               def our(self):
                     print("成功调用了")
  

2、多继承：子类有多个直接父亲是称为多继承
假设子类是

>>>Class ChildClass(ParentClass1,ParentClass2,ParentClass3,.........ParentClassn):
               pass

>>>class ParentClassA(object):          #父类
              cm = 66
              def me(self):
                    print("被调用了“）
>>>class ParentClassB(object):          #父类
                cn = 88
                def us(self):
                     print("被调用了“）
>>>class ChildClass(ParentClassA,ParentClassB):        #子类，有两个直接父类
               def our(self):
                     print("成功调用了")
  

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

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

>>>class ParentClassA(object):          #父类
              cm = 66
              def me(self):
                    print("被调用了“）
>>>class ChildClass(ParentClassA):        #子类
           #添加的父类没有的属性和方法
               cpb = 88
               def our(self):
                     print("成功调用了")
  

重写：

关于重写（覆盖）

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

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

MRO:method resolution order（方法解析顺序）

关于MRO

• 它指的是对于一棵类继承树，当调用最底层类对象所对应实例对象的方法时，python解释器在类继承树上搜索方法的顺序。
• 对于一棵类继承树，可以调用最底层的方法mro()（返回列表）或访问最底层类对象的特殊属性__mro__（返回元组）,获得这颗类继承的MRO
  
  在类继承树上搜索方法的顺序是从左往右，从下到上
  所以这个搜索顺序为D->B->C->A->object

>>>print(D.__mro__)          #可查看类继承树的属性顺序
>>>print(D.mro())                #可查看类继承树的方法顺序

• 在子类重写后的方法中通过super()调用父类中被重写的方法时，在父类中搜索方法的顺序基于以该子类为最底层类对象的类继承树的MRO。
• 如果想调用指定父类中的被重写的方法，可以给super()传入两个实参：super(a_type,object),其中，第一个实参a_Type是个类对象，第二个实参object是个实例对象，这样，被指定放的父类是：object所对应类对象的mro中，a_type后面个类对象（super(a_type,object)的意思是按类继承树搜素a_type后面那个类对象）
  

多态：在不考虑对象类型的情况下使用对象

关于多态

• 除了封装和继承，多态也是面向对象编程的三大特征之一
• 简单地说，多态就是“具有多种形态”，它指的是：即便不知道一个变量所引用的对象到底是什么类型，仍然可以通过这个变量调用方法，在运行过程中根据变量所引用对象的类型。动态地决定调用那个对象中的方法。

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


python是动态语言，在调用时不会检查参数的类型

• 动态语言的多态崇尚“鸭子类型”：当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就可以被称为鸭子
• 在鸭子类型中，我们并不关心对象四什么类型，到底是不是鸭子，只关心对象的行为
• 在上面的程序中，我们并关心变量parent所引用的对象四什么类型，到底是不是ParentClass或其子类类型，只关心变量parent所引用的对象是否有do_sth()这个方法

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

面向对象编程内容会介绍详细一点，后面还会有博客更新哟