python 面向对象三大特性

面向对象三大特性：继承，多态与封装

什么是继承

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

派生类或子类。python中类的继承分为：单继承和多继承

class A:pass   #父类，基类，超类
class B:pass   #父类，基类，超类
class A_son(A,B):pass  #子类，派生类
class AB_son(A,B):pass  #子类，派生类
'''
一个类 可以被多个类继承
一个类 可以继承多个父类 —— python里
在python3里面都有父类，object 默认是继承object
父类中没有的属性，在子类中出现 叫做派生属性
父类中没有的方法，在子类中出现 叫做派生方法
只要是子类的对象调用，子类中有的名字，一定用子类的，子类没有才找父类，如果父类没有就报错
如果父类 子类都有 用子类的
如果还想用父类 单独调用父类 需要自己传self参数
如果还想用父类 单独调用父类 需要自己传self参数
'''
super().__init__()#子类调用父类

正常的代码中，单继承减少了代码的重复，继承表达的是一种,子类是父类的关系。

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)  # 只在新式类中有，python3中所有类都是新式类
        self.kind = kind       # 派生属性
    def eat(self):print('dog eating')
j = Dog('aaa',200,500,'teddy')
print(j.name)
j.eat()
super(Dog,j).eat()

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

d = D()
print(D.mro())
'''
新式类中的继承顺序 ： 广度优先
经典类 如果你直接创建一个类在2.7中就是经典类 深度优先
单继承 ： 子类有的用子类 子类没有用父类
多继承中，我们子类的对象调用一个方法，默认是就近原则，找的顺序是什么？
经典类中 深度优先
新式类中 广度优先
python2.7 新式类和经典类共存，新式类要继承object
python3   只有新式类，默认继承object
经典类和新式类还有一个区别  mro方法只在新式类中存在
super 只在python3中存在
super的本质 ：不是单纯找父类 而是根据调用者的节点位置的广度优先顺序来的
'''

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

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

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

抽象类与接口类

继承有两种用途：

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

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

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

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

class Wechatpay:
    def fuqian(self,money):   
        '''
        实现了pay的功能，但是名字不一样
        所以会报错
        '''
        print('微信支付了%s元'%money)


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


p = Alipay()
pay(p,200)

手动抛出异常：NotImplementedError来解决开发中遇到的问题

class Payment:
    def pay(self):
        raise NotImplementedError

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


p = Wechatpay()  #这里不报错
pay(p,200)      #这里报错了
#借用abc模块来实现接口
from abc import ABCMeta,abstractmethod

class Payment(metaclass=ABCMeta):
    @abstractmethod
    def pay(self,money):
        pass


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

p = Wechatpay() #不调就报错了

依赖倒置原则：高层模块不应该依赖低层模块，二者都应该依赖其抽象；抽象不应该依赖细节；细节依赖抽象。换言之，要针对借口编程，而不是 针对实现编程。

接口类：默认多继承，接口类中所有方法都必须不能实现

抽象类

什么是抽象类

    与java一样，python也有抽象类的概念但是同样需要借助模块实现，抽象类是一个特殊的类，它的特殊之处在于只能被继承，不能被实例化

为什么要有抽象类

    如果说类是从一堆对象中抽取相同的内容而来的，那么抽象类就是从一堆类中抽取相同的内容而来的，内容包括数据属性和函数属性。

　 比如我们有香蕉的类，有苹果的类，有桃子的类，从这些类抽取相同的内容就是水果这个抽象的类，你吃水果时，要么是吃一个具体的香蕉，要么是吃一个具体的桃子。。。。。。你永远无法吃到一个叫做水果的东西。

    从设计角度去看，如果类是从现实对象抽象而来的，那么抽象类就是基于类抽象而来的。

　 从实现角度来看，抽象类与普通类的不同之处在于：抽象类中有抽象方法，该类不能被实例化，只能被继承，且子类必须实现抽象方法。这一点与接口有点类似，但其实是不同的，即将揭晓答案

#一切皆文件
import abc #利用abc模块实现抽象类

class All_file(metaclass=abc.ABCMeta):
    all_type='file'
    @abc.abstractmethod #定义抽象方法，无需实现功能
    def read(self):
        '子类必须定义读功能'
        pass

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

# class Txt(All_file):
#     pass
#
# t1=Txt() #报错,子类没有定义抽象方法

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)
print(yingpanwenjian.all_type)
print(jinchengwenjian.all_type)
'''
抽象类：规范
一般情况下 单继承 能实现的功能都是一样的
多继承的情况 由于功能比较复杂，所以不容易抽象出相同的功能的
功能的具体实现写在文件中
抽象类还是接口类：面向对象的开发规范 都不能实例化
python中没有接口类：java里有借口Interface这个概念
python中自带多继承 所以我们直接用class来实现接口类
python中支持抽象类：一般情况下 单继承，且可以是实现python代码
'''