python之路 -- 面向对象基础2

面向对象的三大特征

　　——继承，多态，封装

继承

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

 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类的父类

　　猫可以：喵喵叫、吃、喝、拉、撒

　　狗可以：汪汪叫、吃、喝、拉、撒

如果我们要分别为猫和狗创建一个类，那么就需要为 猫 和 狗 实现他们所有的功能，伪代码如下：
#继承的代码实现
class Animal:

    def eat(self):
        print("%s 吃 " %self.name)

    def drink(self):
        print ("%s 喝 " %self.name)

    def shit(self):
        print ("%s 拉 " %self.name)

    def pee(self):
        print ("%s 撒 " %self.name)


class Cat(Animal):

    def __init__(self, name):
        self.name = name
        self.breed = '猫'

    def cry(self):
        print('喵喵叫')

class Dog(Animal):

    def __init__(self, name):
        self.name = name
        self.breed='狗'

    def cry(self):
        print('汪汪叫')
        
c1 = Cat('小白家的小黑猫')
c1.eat()

#输出结果为：
#小白家的小黑猫 吃 

子类也可以添加自己新的属性或者在自己这里重新定义这些属性（不会影响到父类）
需要注意的是，一旦重新定义了自己的属性且与父类重名，那么调用新增的属性时，就以自己为准了。（也就是重写父类方法）
所谓重写，就是子类中，有一个和父类相同名字的方法，在子类中的方法会覆盖掉父类中同名的方法

新式类和经典类

# python2.7 新式类和经典类共存，新式类要继承object
# python3中所有类都是新式类,python3中的类默认继承object
    ——新式类继承顺序广度优先
    ——经典类继承顺序深度优先
# 经典类和新式类还有一个区别  mro方法只在新式类中存在

继承顺序问题

class F:
    def func(self):
        print('F')
class A(F):
    def func(self):
        print('A')
class B(A):pass
    # def func(self):
    #     print('B')
class E(F):
    def func(self):
        print('E')
class C(E):
    def func(self):
        print('C')
class D(B,C):
    pass
    # def func(self):print('D')

d = D()
d.func()    #输出的结果为：A
print(D.mro())  #打印D的继承关系

 

图一的继承顺序为：
D->B->A->C->E->F
图二的继承顺序为：
D->B->A->F->C->E

# 只要是子类的对象调用，子类中有的名字 一定用子类的，子类中没有才找父类的，如果父类也没有报错
# 如果父类 子类都有 用子类的
    # 如果还想用父类的，单独调用父类的:
    #       父类名.方法名 需要自己传self参数
    #       super().方法名 不需要自己传self

　super的使用

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):
        super().__init__(name,aggr,hp)  #<==>Animal.__init__(self,name,aggr,hp)
        self.kind = kind       # 派生属性
    def eat(self):print('dog eating')

jin = Dog('狗',200,500,'teddy')
print(jin.name)
jin.eat()
super(Dog,jin).eat()  在外部使用super的时候需要传类和对象

super的查找顺序和继承顺序相同
#super 只在python3中存在
 super的本质 ：不是单纯找父类 而是根据调用者的节点位置的广度优先顺序来的

 

class A():
    def func(self): print('A')

class B(A):
    def func(self):
        super().func()
        print('B')

class C(A):
    def func(self):
        super().func()
        print('C')

class D(B,C):
    def func(self):
        super().func()    
        print('D')
#super的查找顺序和继承顺序相同
d = D()
d.func()    #输出结果为：A C B D
print(D.mro())    #D->B->C->A

接口类

python中没有接口类，只是可以实现一个有接口类功能的类9(有抽象类)

继承有两种用途：

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

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

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

class Applepay:
    '''
    apple pay支付
    '''
    def pay(self,money):
        print('apple pay支付了%s元'%money)


def pay(payment,money):
    '''
    支付函数，总体负责支付
    对应支付的对象和要支付的金额
    '''
    payment.pay(money)


p = Alipay()
pay(p,200)    #支付宝支付了200元

接口类的多继承

#接口类的多继承
#tiger 走路 游泳
#swan 走路 游泳 飞
#oldying 走路 飞
from abc import abstractmethod,ABCMeta    #1.引用这个模块
class Swim_Animal(metaclass=ABCMeta):     #2.传入这个metaclass=ABCMeta
    @abstractmethod                       #3.加上此装饰器的语法糖@abstractmethod
    def swim(self):pass                   #满足这3点的就可以成为接口类

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

from abc import ABCMeta,abstractmethod

class Payment(metaclass=ABCMeta):
    @abstractmethod
    def pay(money):
        print("支付了%s" % money)

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

# p = Wechatpay(200) #此处实例化会报错
#只实例化一个类，不调用类中的方法就会报错

p = Wechatpay.fuqian(200)
p2 = Wechatpay.pay(100)
p3 = Payment.pay(50)
#执行结果：
#微信支付了200元
#支付了100
#支付了50

 抽象类

与java一样，python也有抽象类的概念但是同样需要借助模块实现，抽象类是一个特殊的类，它的特殊之处在于只能被继承，不能被实例化
抽象类与普通类的不同之处在于：抽象类中有抽象方法，该类不能被实例化，只能被继承，且子类必须实现抽象方法。这一点与接口有点类似，但其实是不同的，
python支持抽象类，多继承。

抽象类可以有构造方法，接口不能有构造方法；

多态

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

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')

多态动态绑定（在继承的背景下使用时，有时也称为多态性）
多态性是指在不考虑实例类型的情况下使用实例

鸭子类型
所谓鸭子类型，定义是‘是动态类型的一种风格‘。一个对象的特征不是由父类决定，而是通过对象的方法决定的。

封装

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

class Person:
    __key = 123  # 私有静态属性
    def __init__(self,name,passwd):
        self.name = name
        self.__passwd = passwd   # 私有属性

    def __get_pwd(self):         # 私有方法
        return self.__passwd   #只要在类的内部使用私有属性，就会自动的带上_类名

    def login(self):          # 正常的方法调用私有的方法
        self.__get_pwd()

alex = Person('alex','alex3714')
print(alex._Person__passwd)   # _类名__属性名（在内的外部只能通过这种方式调用私有属性和方法）
print(alex.get_pwd())        #此处的调用方法会报错

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

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

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

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