面向对象三大特性（图没有完整）

面向对象的三大特性：封装、继承、多态

一、继承

继承是一种创建新类的方式，在python中，新建的类可以继承一个或多个父类，父类又可称为基类或超类，新建的类称为派生类或子类

1、单继承和多继承

python中类的继承分为：单继承和多继承

class ParentClass1: #定义父类
    pass

class ParentClass2: #定义父类
    pass

class SubClass1(ParentClass1):                  #单继承，基类是ParentClass1，派生类是SubClass
    pass

class SubClass2(ParentClass1,ParentClass2):     #python支持多继承，用逗号分隔开多个继承的类
    pass

查看继承

>>> SubClass1.__bases__                 #__base__只查看从左到右继承的第一个子类，__bases__则是查看所有继承的父类
(<class '__main__.ParentClass1'>,)
>>> SubClass2.__bases__
(<class '__main__.ParentClass1'>, <class '__main__.ParentClass2'>)

提示：如果没有指定基类，python的类会默认继承object类，object是所有python类的基类，它提供了一些常见方法（如__str__）的实现

>>> ParentClass1.__bases__
(<class 'object'>,)
>>> ParentClass2.__bases__
(<class 'object'>,)

2、继承与抽象（先抽象再继承）

抽象：即抽取类似或者说比较像的部分

抽象分成两个层次

　　将奥巴马和梅西这俩对象比较像的部分抽取成类

　　将人，猪，狗这三个类比较像的部分抽取成父类

抽象最主要的作用是划分类别（可以隔离关注点，降低复杂度）

继承：是基于抽象的结果，通过编程语言去实现它，先经历抽象这个过程，才能通过继承的方式去表达出抽象的结构

抽象只是分析和设计的过程中，一个动作或者说是一种技巧，通过抽象可以得到类

 

3、继承与重用性

 在开发程序的过程中，如果我们定义了一个类A,然后又想新建立另外一个类B,但是类B的大部分内容与类A的相同时我们不可能从头开始写一个类B,这就用到了类的继承的概念

人和狗都有共同的属性和方法，通过继承的方式新建狗和人类，让狗类和人类继承动物类，狗类和人类会‘遗传’动物的所有属性（数据属性和函数属性），实现代码重用

class Animal:
    '''
    人和狗都是动物，所以创造一个Animal基类
    '''
    def __init__(self, name, aggressivity, life_value):
        self.name = name                        #人和狗都有自己的昵称;
        self.aggressivity = aggressivity        #人和狗都有自己的攻击力;
        self.life_value = life_value            #人和狗都有自己的生命值;

    def eat(self):                              #人和狗都可以吃
        print('%s is eating'%self.name)

class Dog(Animal):
    pass

class Person(Animal):
    pass

egg = Person('egon',10,1000)
ha2 = Dog('二愣子',50,1000)
egg.eat()
ha2.eat()

执行结果：

egon is eating
二愣子 is eating

4、派生

当然子类也可以添加自己新的属性或者在自己这里重新定义这些属性（不会影响到父类），需要注意的是，一旦重新定义了自己的属性且与父类重名，那么调用新增的属性时，就以自己为准了

class Animal:
    '''
    人和狗都是动物，所以创造一个Animal基类
    '''
    def __init__(self, name, aggressivity, life_value):
        self.name = name                  #人和狗都有自己的昵称;
        self.aggressivity = aggressivity  #人和狗都有自己的攻击力;
        self.life_value = life_value      #人和狗都有自己的生命值;

    def eat(self):
        print('%s is eating'%self.name)


class Dog(Animal):
    '''
    狗类，继承Animal类
    '''
    def bite(self, people):
        '''
        派生：狗有咬人的技能
        :param people:
        '''
        people.life_value -= self.aggressivity


class Person(Animal):
    '''
    人类，继承Animal
    '''
    def attack(self, dog):
        '''
        派生：人有攻击的技能
        :param dog:
        '''
        dog.life_value -= self.aggressivity


egg = Person('egon',10,1000)
ha2 = Dog('二愣子',50,1000)
print(ha2.life_value)
print(egg.attack(ha2))
print(ha2.life_value)

输出结果：

1000
None
990

5、接口类

继承有两种用途:

　　继承基类的方法，并且做出自己的改变或者扩展（代码重用）

　　声明某个子类兼容与某基类，定义一个接口类interface,接口类中定义了一些接口名（就是函数名）且并未实现接口的功能，子类继承接口类，并且实现接口的功能

接口类

借用abc模块来实现接口

from abc import ABCMeta,abstractmethod

class Payment(metaclass=ABCMeta):
    @abstractmethod                 #调用@abstractmethod规定子类必须有pay方法
    def pay(self,money):
        pass


class Wechatpay(Payment):
    def pay(self,money):
        print('微信支付了%s元'%money)


obj = Wechatpay()

6、多继承

　　python的类可以继承多个类，java和c#中则只能继承一个类

　　python的类如果继承了多个类，那么其寻找方法有两种，分别：深度优先和广度优先

 当类是经典类时，多继承情况下，会按照深度优先方式查找

当类是新式类时，多继承情况下，会按照广度优先方式查找

如果类或父类继承了object类，都为新式类，python3默认都为新式类

继承顺序

class A(object):
    def test(self):
        print('from A')

class B(A):
    def test(self):
        print('from B')

class C(A):
    def test(self):
        print('from C')

class D(B):
    def test(self):
        print('from D')

class E(C):
    def test(self):
        print('from E')

class F(D,E):
    # def test(self):
    #     print('from F')
    pass
f1=F()
f1.test()
print(F.__mro__) #只有新式才有这个属性可以查看线性列表，经典类没有这个属性

#新式类继承顺序:F->D->B->E->C->A
#经典类继承顺序:F->D->B->A->E->C
#python3中统一都是新式类
#pyhon2中才分新式类与经典类

7、继承原理

python到底是如何实现继承的，对于你定义的每一个类，python会计算出一个方法解析顺序（MRO）列表，这个MRO列表就是一个简单的所有基类的线性顺序列表，例如

>>> F.mro() #等同于F.__mro__
[<class '__main__.F'>, <class '__main__.D'>, <class '__main__.B'>, <class '__main__.E'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]

为了实现继承，python会再MRO列表上从左到右开始查找基类，直到找到第一个匹配这个属性的类为止

而这个MRO列表的构造是通过一个C3线性化算法来实现的，我们不去深究这个算法的数学原理，它实际上就是合并所有父类的MRO列表并遵循如下三条准则：

1、子类会先于父类被检查

2、多个父类会根据他们在列表中的顺序被检查

3、如果对下一个类存在两个合法的选择，选择第一个父类

二、封装

封装：隐藏对象的属性和实现细节，仅对外提供公共访问方式

1、封装的好处

1、将变化隔离

2、便于使用

3、提高复用性

4、提高安全性

2、私有变量和私有方法

私有变量

类中所有双下划线开头的名称如__x都会自动变形成：_类名__x的形式

class A:

    __N=0                      #类的数据属性就应该是共享的,但是语法上是可以把类的数据属性设置成私有的如__N,会变形为_A__N

    def __init__(self):
        self.__X=10            #变形为self._A__X

    def __foo(self):           #变形为_A__foo
        print('from A')

    def bar(self):
        self.__foo()           #只有在类内部才可以通过__foo的形式访问到.


A._A__N是可以访问到的，即这种操作并不是严格意义上的限制外部访问，仅仅只是一种语法意义上的变形

私有方法

在继承中，父类如果不想让子类覆盖自己的方法，可以将方法定义为私有的

#正常情况
>>> class A:
...     def fa(self):
...         print('from A')
...     def test(self):
...         self.fa()
... 
>>> class B(A):
...     def fa(self):
...         print('from B')
... 
>>> b=B()
>>> b.test()
from B


#把fa定义成私有的，即__fa
>>> class A:
...     def __fa(self): #在定义时就变形为_A__fa
...         print('from A')
...     def test(self):
...         self.__fa() #只会与自己所在的类为准,即调用_A__fa
... 
>>> class B(A):
...     def __fa(self):
...         print('from B')
... 
>>> b=B()
>>> b.test()
from A

3、封装与扩展性

封装在于明确区分内外，使得类实现者可以修改封装内的东西而不影响外部调用者的代码，而外部使用者只知道一个接口(函数），只要接口（函数）名，参数不变，使用者的代码永远无需改变。这就提供了一个良好的合作基础——或者说，只要接口这个基础约定不变，则代码改变不足为虑

#类的设计者
class Room:

    def __init__(self,name,owner,width,length,high):
        self.name=name
        self.owner=owner
        self.__width=width
        self.__length=length
        self.__high=high

    def tell_area(self):            #对外提供的接口，隐藏了内部的实现细节，此时我们想求的是面积
        return self.__width * self.__length


#使用者
>>> r1=Room('卧室','egon',20,20,20)
>>> r1.tell_area()                  #使用者调用接口tell_area



#类的设计者，轻松的扩展了功能，而类的使用者完全不需要改变自己的代码
class Room:

    def __init__(self,name,owner,width,length,high):
        self.name=name
        self.owner=owner
        self.__width=width
        self.__length=length
        self.__high=high

    def tell_area(self):            #对外提供的接口，隐藏内部实现，此时我们想求的是体积,内部逻辑变了,只需求修该下列一行就可以很简答的实现,而且外部调用感知不到,仍然使用该方法，但是功能已经变了
        return self.__width * self.__length * self.__high


#对于仍然在使用tell_area接口的人来说，根本无需改动自己的代码，就可以用上新功能
>>> r1.tell_area()

property属性

class Foo:
    def __init__(self,val):
        self.__NAME=val                 #将所有的数据属性都隐藏起来

    @property
    def name(self):
        return self.__NAME              #obj.name访问的是self.__NAME(这也是真实值的存放位置)

    @name.setter
    def name(self,value):
        if not isinstance(value,str):   #在设定值之前进行类型检查
            raise TypeError('%s must be str' %value)
        self.__NAME=value               #通过类型检查后,将值value存放到真实的位置self.__NAME

    @name.deleter
    def name(self):
        raise TypeError('Can not delete')

f=Foo('egon')
print(f.name)
f.name=10          #抛出异常'TypeError: 10 must be str'
del f.name         #抛出异常'TypeError: Can not delete'

classmethod

把一个方法绑定给类：类.绑定到类的方法（），会把类本身当做第一个参数自动传给绑定到类的方法

class Classmethod_Demo():
    role = 'dog'

    @classmethod
    def func(cls):
        print(cls.role)

Classmethod_Demo.func()

staticmethod

静态方法，此时对象调类里面的函数不是绑定方法，而是普通的函数

class Staticmethod_Demo():
    role = 'dog'

    @staticmethod
    def func():
        print("当普通方法用")

Staticmethod_Demo.func()

三、多态

多态指的是一类事物有多种形态

动物有多种形态：人，狗，猪

import abc

class Animal(metaclass=abc.ABCMeta):     #同一类事物:动物
    @abc.abstractmethod
    def talk(self):
        pass

class People(Animal):                   #动物的形态之一:人
    def talk(self):
        print('say hello')

class Dog(Animal):                      #动物的形态之二:狗
    def talk(self):
        print('say wangwang')

class Pig(Animal):                      #动物的形态之三:猪
    def talk(self):
        print('say aoao')

文件有多种形态：文本文件，可执行文件

import abc

class File(metaclass=abc.ABCMeta):          #同一类事物:文件
    @abc.abstractmethod
    def click(self):
        pass

class Text(File):                           #文件的形态之一:文本文件
    def click(self):
        print('open file')

class ExeFile(File):                        #文件的形态之二:可执行文件
    def click(self):
        print('execute file')