Python之继承，接口归一化和抽象

1、什么是继承？

继承指的是类与类之间的关系，功能之一就是用来解决代码重用问题

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

2、继承与抽象

抽象分成两个层次：
1.将奥巴马和梅西这俩对象比较像的部分抽取成类；
2.将人，猪，狗这三个类比较像的部分抽取成父类。
抽象最主要的作用是划分类别（可以隔离关注点，降低复杂度）

继承：
是基于抽象的结果，通过编程语言去实现它，肯定是先经历抽象这个过程，才能通过继承的方式去表达出抽象的结构。
抽象只是分析和设计的过程中，一个动作或者说一种技巧，通过抽象可以得到类

3、派生
1.在父类的基础上产生子类，产生的子类就叫做派生类
2.父类里没有的方法，在子类中有了，这样的方法就叫做派生方法。
3.父类里有，子类也有的方法，就叫做方法的重写（就是把父类里的方法重写了）

组合与重用性
重用性：
方式1：不通过继承的方式重用属性，指名道姓的使用哪个类的属性
提示：用已经有的类建立一个新的类，这样就重用了已经有的软件中的一部分甚至大部分，大大省了编程工作量，这就是常说的软件重用，不仅可以重用自己的类，也可以继承别人的，比如标准库，来定制新的数据类型，这样就是大大缩短了软件开发周期，对大型软件开发来说，意义重大.
注意：像g1.life之类的属性引用，会先从实例中找life，然后去类中找，然后再去父类中找...直到最顶级的父类。
 

#!encoding:utf-8
class animal():   # 定义父类
    country  =  'china'     # 这个叫类的变量
    def __init__(self,name,age):
        self.name=name   # 这些又叫数据属性
        self.age=age

    def walk(self):         # 类的函数，方法，动态属性
        print('%s is walking'%self.name)

    def say(self):
        print('%s is saying'%self.name)

class people(animal):  # 子类继承父类
    def work(self):#属于派生出来的可以工作
        print('%s is working'%self.name)

class pig(animal):    # 子类继承父类
    def eated(self):#属于派生出来的可以被作为食物
        print('%s is eated'%self.name)


class dog(animal):  # 子类继承父类
    def say(self):#方法可以重用，重写
        print('%s is saying1111'%self.name)

    def bulie(self):#属于派生出来的可以捕猎技能
        print('%s can bulie'%self.name)

print people.__bases__ # 查看所有继承的父类
print pig.__bases__
print dog.__bases__

aobama=people('zhangsan',60)   # 实例化一个对象
print(aobama.name)
aobama.walk()
aobama.work()


aobama1=pig('pig',1)   # 实例化一个对象
print(aobama1.name)
aobama1.walk()
aobama1.eated()

aobama2=dog('pig',1)   # 实例化一个对象
print(aobama1.name)
aobama2.say()
aobama2.bulie()

 

接口与归一化设计  常用的接口封装或归一化

a、为何要用接口？
接口提取了一群类共同的函数，可以把接口当做一个函数的集合。
然后让子类去实现接口中的函数。
这么做的意义在于归一化，什么叫归一化，就是只要是基于同一个接口实现的类，那么所有的这些类产生的对象在使用时，从用法上来说都一样。
归一化的好处在于：
归一化让使用者无需关心对象的类是什么，只需要的知道这些对象都具备某些功能就可以了，这极大地降低了使用者的使用难度
 

#!encoding:utf-8
class Interface:#定义接口Interface类来模仿接口的概念，python中压根就没有interface关键字来定义一个接口。
    def read(self): #定接口函数read
        pass
    def write(self): #定义接口函数write
        pass


class Txt(Interface): #文本，具体实现read和write
    def read(self):
        print('文本数据的读取方法')
    def write(self):
        print('文本数据的读取方法')

class Sata(Interface): #磁盘，具体实现read和write
    def read(self):
        print('硬盘数据的读取方法')
    def write(self):
        print('硬盘数据的读取方法')

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


if __name__ == '__main__':
    Txt().write()
    Txt().read()

    Sata().write()
    Sata().read()

    Process().write()
    Process().read()

抽象类

子类必须继承抽象类的方法，不然报错
什么是抽象类？
与java一样，python也有抽象类的概念但是同样需要借助模块实现，抽象类是一个特殊的类，它的特殊之处在于只能被继承，不能被实例化

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

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

从设计角度去看，如果类是从现实对象抽象而来的，那么抽象类就是基于类抽象而来的。
　 从实现角度来看，抽象类与普通类的不同之处在于：抽象类中只能有抽象方法（没有实现功能），该类不能被实例化，只能被继承，且子类必须实现抽象方法。

抽象类与接口
抽象类的本质还是类，指的是一组类的相似性，包括数据属性（如all_type）和函数属性（如read、write），而接口只强调函数属性的相似性。

抽象类是一个介于类和接口直接的一个概念，同时具备类和接口的部分特性，可以用来实现归一化设计

#_*_coding:utf-8_*_
import abc #利用abc模块实现抽象类
#抽象类：本质还是类，与普通类额外的特点的是：加了装饰器的函数，子类必须实现他们
class All_file(object):# 抽象类是用来被子类继承的，不是用来实例化的,python3中这样写All_file(metaclass=abc.ABCMeta)  
    __metaclass__ = abc.ABCMeta
    all_type='file'
    @abc.abstractmethod #定义抽象方法，无需实现功能, # 如果子类没有我这个函数，主动抛出异常
    def read(self):
        '子类必须定义读功能'
        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)
print(yingpanwenjian.all_type)
print(jinchengwenjian.all_type)