面向对象的三大特性

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

一、继承

1、什么是继承？

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

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

class A:pass   # 父类，基类，超类
class B:pass   # 父类，基类，超类
class A_son(A,B):pass # 子类，派生类
class AB_son(A,B):pass # 子类，派生类

注：一个类可以被多个类继承；

       一个类可以继承多个类。

2、查看继承

class A:pass   
class B:pass   
class A_son(A,B):pass 
class AB_son(A,B):pass 

print(A_son.__base__)  #__base__只查看从左到右继承的第一个子类，
#(<class '__main__.A'>, <class '__main__.B'>)
print(AB_son.__bases__)  #__bases__则是查看所有继承的父类
#(<class '__main__.A'>, <class '__main__.B'>)
print(A.__bases__)  #python的类会默认继承object类
#(<class 'object'>,)

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

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

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

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

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

4、继承与重用性

有两个类，类B的内容与类A大部分相同时，可以用到类的继承，让B继承A，B会继承A的所有属性（数据属性和函数属性），实现代码的重用。

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

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

5、派生

在继承中，子类也可以添加自己新的属性，也可以在不影响父类的情况下重新定义这些属性。

#人狗大战
class Animal:
    def __init__(self,name,aggr,hp):
        self.name = name
        self.aggr = aggr
        self.hp = hp

    def eat(self):
        print('吃药回血')
        self.hp+=100

class Dog(Animal):
    def __init__(self,name,aggr,hp,kind):
        Animal.__init__(self,name,aggr,hp)  #
        self.kind = kind       # 派生属性
    def eat(self):
        Animal.eat(self)   # 如果既想实现新的功能也想使用父类原本的功能，还需要在子类中再调用父类
        self.teeth = 2
    def bite(self,person):   # 派生方法
        person.hp -= self.aggr

jin = Dog('金老板',100,500,'吉娃娃')
jin.eat()
print(jin.hp)

class Person(Animal):
    def __init__(self,name,aggr,hp,sex):
        Animal.__init__(self,name,aggr,hp)
        self.sex = sex       # 派生属性
        self.money = 0       # 派生属性

    def attack(self,dog):
        dog.hp -= self.aggr

    def get_weapon(self,weapon):
        if self.money >= weapon.price:
            self.money -= weapon.price
            self.weapon = weapon
            self.aggr += weapon.aggr
        else:
            print("余额不足，请先充值")
alex = Person('alex',1,2,None)
alex.eat()
print(alex.hp)

jin.bite(alex)
print(alex.hp)

注意：

1)、父类中没有的属性 在子类中出现 叫做派生属性；

2)、父类中没有的方法 在子类中出现 叫做派生方法；

3)、只要是子类的对象调用，子类中有的名字 一定用子类的，子类中没有才找父类的，如果父类也没有报错

4)、如果父类 子类都有 用子类的

              如果还想用父类的，单独调用父类的:   

                          父类名.方法名 需要自己传self参数   

                          super().方法名 不需要自己传self（只在新式类中有，python3中所有类都是新式类）

5)、正常的代码中 单继承 === 减少了代码的重复

6)、继承表达的是一种 子类是父类的关系

7）、如果子类中实现了调用父类的方法

　　　　在类内：super(子类，self).方法名（）  super().__init__(参数)

　　　　在类外：super(子类名，对象名).方法名（）

通过继承建立了派生类与基类之间的关系，它是一种'是'的关系，比如白马是马，人是动物。

当类之间有很多相同的功能，提取这些共同的功能做成基类，用继承比较好。

继承的实例

class Animal:      #父类  基类  超类
 2     def __init__(self,name,life_value,aggr):
 3         self.name= name
 4         self.life_value = life_value
 5         self.aggr = aggr  #攻击力
 6     def eat(self):
 7         self.life_value += 10  #谁调谁的血量就增加
 8 
 9 class Person(Animal):  #子类  派生类
10     def __init__(self, money, name, life_value, aggr):
11         super().__init__(name, life_value, aggr)
12         self.money = money  #派生出来的一个属性
13     def attack(self,enemy):    #人的派生方法
14         #enemy.life_value = enemy.life_value - self.aggr
15         enemy.life_value -= self.aggr
16 
17 class Dog(Animal): #子类  派生类
18     def __init__(self,name,breed, life_value,aggr):
19         # Animal.__init__(self,name,breed, life_value,aggr)#让子类执行父类的方法 就是父类名.方法名（参数），连self都得传
20         super().__init__(name,life_value,aggr) #super关键字  ，都不用传self了，在新式类里的
21         # super(Dog,self).__init__(name,life_value,aggr)  #上面super是简写
22         self.breed = breed
23     def bite(self,person):   #狗的派生方法
24         person.life_value -= self.aggr
25     def eat(self):  #父类方法的重写
26         super().eat()
27         print('dog is eating')
28 
29 # ha2 = Dog('旺财','哈士奇',20000,100)
30 # egg = Person('egon',500,1000,50)
31 # print(egg.aggr)
32 # print(ha2.aggr)
33 # egg.eat()
34 # print(egg.life_value)
35 #
36 # egg.eat()
37 # print(egg.life_value)
38 #
39 # ha2.eat()
40 # print(ha2.life_value)
41 #
42 # print(egg.life_value)
43 # ha2.bite(egg)
44 # print(egg.life_value)
45 #
46 
47 ha2 = Dog('牛头梗','旺财',20000,100)
48 print(ha2.life_value)
49 ha2.eat()  #如果父类有的方法子类里面也有，那么就叫做方法的重写，就不执行父类的了，去执行子类了
50 print(ha2.life_value)
51 
52 
53 super(Dog,ha2).eat() #生掉父类的方法，但是不推荐这样用
54 print(ha2.life_value)
55 
56 #在继承中，如果子类有的方法就执行子类的
57 # 如果子类没有的方法就执行父类的

6、抽象类与接口类

6.1、接口类

接口类：python原生不支持

本质：是做代码规范用的，希望在子类中实现和父类方法名字完全一样的方法。

from abc import abstractmethod,ABCMeta
class Payment(metaclass=ABCMeta):  # 元类 默认的元类 type
    @abstractmethod
    def pay(self,money):pass   # 没有实现这个方法
# 规范 ：接口类或者抽象类都可以
# 接口类 支持多继承，接口类中的所有的方法都必须不能实现 —— java
# 抽象类 不支持多继承，抽象类中方法可以有一些代码的实现 —— java
class Wechat(Payment):
    def pay(self,money):
        print('已经用微信支付了%s元'%money)

class Alipay(Payment):
    def pay(self,money):
        print('已经用支付宝支付了%s元' % money)

class Applepay(Payment):
    def pay(self,money):
        print('已经用applepay支付了%s元' % money)

def pay(pay_obj,money):  # 统一支付入口
    pay_obj.pay(money)

wechat = Wechat()
ali = Alipay()
app = Applepay()
wechat.pay(100)
ali.pay(200)

接口类的多继承：

# tiger 走路 游泳
# swan 走路 游泳 飞
# oldying 走路 飞
from abc import abstractmethod,ABCMeta
class Swim_Animal(metaclass=ABCMeta):
    @abstractmethod
    def swim(self):pass

class Walk_Animal(metaclass=ABCMeta):
    @abstractmethod
    def walk(self):pass

class Fly_Animal(metaclass=ABCMeta):
    @abstractmethod
    def fly(self):pass

class Tiger(Walk_Animal,Swim_Animal):
    def walk(self):
        pass
    def swim(self):
        pass
class OldYing(Fly_Animal,Walk_Animal):pass
class Swan(Swim_Animal,Walk_Animal,Fly_Animal):pass

接口类，  刚好满足接口隔离原则 面向对象开发的思想 、规范。

6.2、抽象类

抽象类：规范

一般情况下 单继承 能实现的功能都是一样的，所以在父类中可以有一些简单的基础实现
多继承的情况 由于功能比较复杂，所以不容易抽象出相同的功能的具体实现写在父类中

利用abc模块实现抽象类

import abc #利用abc模块实现抽象类
class All_file(metaclass=abc.ABCMeta):
    all_type='file'
    @abc.abstractmethod #定义抽象方法，无需实现功能
    def read(self):
        '子类必须定义读功能'
        with open('filaname') as f:
            pass

    @abc.abstractmethod #定义抽象方法，无需实现功能
    def write(self):
        '子类必须定义写功能'
        pass

class Txt(All_file): #子类继承抽象类，但是必须定义read和write方法
    def read(self):
        print('文本数据的读取方法')
    def write(self):
        print('文本数据的读取方法')

class Sata(All_file): #子类继承抽象类，但是必须定义read和write方法
    def read(self):
        print('硬盘数据的读取方法')

    def write(self):
        print('硬盘数据的读取方法')

class Process(All_file): #子类继承抽象类，但是必须定义read和write方法
    def read(self):
        print('进程数据的读取方法')

    def write(self):
        print('进程数据的读取方法')

wenbenwenjian=Txt()    #实例化

yingpanwenjian=Sata()

jinchengwenjian=Process()

#这样大家都是被归一化了,也就是一切皆文件的思想
wenbenwenjian.read()   #文本数据的读取方法
yingpanwenjian.write()  #硬盘数据的读取方法
jinchengwenjian.read()  #进程数据的读取方法

print(wenbenwenjian.all_type)  #file
print(yingpanwenjian.all_type)  #file
print(jinchengwenjian.all_type)   #file

补充：

抽象类还是接口类 ： 面向对象的开发规范 所有的接口类和抽象类都不能实例化

java ：

java里的所有类的继承都是单继承,所以抽象类完美的解决了单继承需求中的规范问题

但对于多继承的需求，由于java本身语法的不支持，所以创建了接口Interface这个概念来解决多继承的规范问题

python：
python中没有接口类 ：
python中自带多继承 所以我们直接用class来实现了接口类
python中支持抽象类 ： 一般情况下 单继承 不能实例化
且可以实现python代码

6.3、接口类和抽象类的区别：

在java的角度上看 是有区别的
java本来就支持单继承 所以就有了抽象类
java没有多继承 所以为了接口隔离原则，设计了接口这个概念，支持多继承了
python既支持单继承也支持多继承，所以对于接口类和抽象类的区别就不那么明显了
甚至在python中没有内置接口类

7、继承顺序

单继承：子类有的用子类，子类没有用父类；

多继承：子类的对象调用一个方法，默认是就近原则；

经典类中：深度优先

新式类中：广度优先

python2.7中：新式类与经典类共存，新式类要继承object

python3：只有新式类，默认继承object

经典类和新式类中还有一个区别：

mro方法只在新式类中存在；

super方法只在python3中新式类中存在；

super的本质：不是直接找父类，而是根据调用者的节点位置的广度优先顺序来的。

二、多态

1、什么是多态？

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

#动物有多种形态：人，狗，猪
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')

2、多态性

多态性是指在不考虑实例类型的情况之下使用实例。

peo=People()
dog=Dog()
pig=Pig()

#peo、dog、pig都是动物,只要是动物肯定有talk方法
#于是我们可以不用考虑它们三者的具体是什么类型,而直接使用
peo.talk()
dog.talk()
pig.talk()

#更进一步,我们可以定义一个统一的接口来使用
def func(obj):
    obj.talk()

3、鸭子类型

鸭子类型是指不依赖父类的情况下实现两个相似类中的同名方法。

#二者都像鸭子,二者看起来都像文件,因而就可以当文件一样去用
class TxtFile:
    def read(self):
        pass

    def write(self):
        pass

class DiskFile:
    def read(self):
        pass
    def write(self):
        pass

三、封装

1、什么是封装？

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

2、封装的好处？

1)、将变化隔离；

2)、便于使用；

3)、提高复用性；

4)、提高安全性。

3、封装原则？

1)、 将不需要对外提供的内容都隐藏起来；

2)、把属性都隐藏，提供公共方法对其访问。

4、私有变量和私有方法

在python中用双下划线开头的方式将属性隐藏起来（设置成私有的）

4.1、私有变量

#其实这仅仅这是一种变形操作
#类中所有双下划线开头的名称如__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是可以访问到的，即这种操作并不是严格意义上的限制外部访问，仅仅只是一种语法意义上的变形

自动变形的特点：

1.类中定义的__x只能在内部使用，如self.__x，引用的就是变形的结果。

2.这种变形其实正是针对外部的变形，在外部是无法通过__x这个名字访问到的。

3.在子类定义的__x不会覆盖在父类定义的__x，因为子类中变形成了：_子类名__x,而父类中变形成了：_父类名__x，即双下滑线开头的属性在继承给子类时，子类是无法覆盖的。

注意：

1.这种机制也并没有真正意义上限制我们从外部直接访问属性，知道了类名和属性名就可以拼出名字：_类名__属性，然后就可以访问了，如a._A__N

2.变形的过程只在类的内部生效,在定义后的赋值操作，不会变形

4.2私有方法

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

#正常情况
>>> 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

5、会用到私有的这个概念的场景：

1)、隐藏起一个属性 不想让类的外部调用

2)、我想保护这个属性，不想让属性随意被改变

3)、我想保护这个属性，不被子类继承