类的继承和派生

一、类的继承、派生和组合

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

在Python3中，所有类都默认继承object，都是新式类。
在Python2中，有经典类和新式类。
没有继承object类以及object的子类的类都是经典类。

1、继承

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

class ParentClass1: #定义父类
    pass

class ParentClass2: #定义父类
    pass

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

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

查看继承

使用<类名.__base__>查看类的第一个父类

使用<类名.__bases__>查看类的父类

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

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

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

class People:
    pass
class Animal:
    pass
class Student(People,Animal):
    pass
print(Student.__bases__)   #(<class ‘__main__.People‘>, <class ‘__main__.Animal‘>)
print(People.__bases__)    #(<class ‘object‘>,)
print(Animal.__bases__)    #(<class ‘object‘>,)
print(Student.__base__)    #<class ‘__main__.People‘> 

继承也是为了解决代码重复的问题，减少代码冗余。
继承是用来创建新的类的一种方式。
继承是一种什么“是”什么的关系。

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

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

抽象分成两个层次：

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

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

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

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

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

3、继承与重用性

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

通过继承的方式新建类B，让B继承A，B会‘遗传’A的所有属性(数据属性和函数属性)，实现代码重用。

class Hero:
    def __init__(self,nickname,aggressivity,life_value):
        self.nickname=nickname
        self.aggressivity=aggressivity
        self.life_value=life_value

    def attack(self,enemy):
        enemy.life_value-=self.aggressivity
class Garen(Hero):
    pass

class Riven(Hero):
    pass

g1=Garen(‘草丛伦‘,100,300)
r1=Riven(‘锐雯雯‘,57,200)

print(g1.life_value)
r1.attack(g1)
print(g1.life_value)

‘‘‘
运行结果
243
‘‘‘

提示：用已经有的类建立一个新的类，这样就重用了已经有的软件中的一部分设置大部分，大大省了编程工作量，这就是常说的软件重用，不仅可以重用自己的类，也可以继承别人的，比如标准库，来定制新的数据类型，这样就是大大缩短了软件开发周期，对大型软件开发来说，意义重大.。

注意：像g1.life_value之类的属性引用，会先从实例中找life_value然后去类中找，然后再去父类中找...直到最顶级的父类。

4、派生

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

class Riven(Hero):
    camp=‘Noxus‘
    def attack(self,enemy): #在自己这里定义新的attack,不再使用父类的attack,且不会影响父类
        print(‘from riven‘)
    def fly(self): #在自己这里定义新的
        print(‘%s is flying‘ %self.nickname)

在子类中，新建的重名的函数属性，在编辑函数内功能的时候，有可能需要重用父类中重名的那个函数功能，应该是用调用普通函数的方式，即：类名.func()，此时就与调用普通函数无异了，因此即便是self参数也要为其传值。

class Riven(Hero):
    camp=‘Noxus‘
    def __init__(self,nickname,aggressivity,life_value,skin):
        Hero.__init__(self,nickname,aggressivity,life_value) #调用父类功能
        self.skin=skin #新属性
    def attack(self,enemy): #在自己这里定义新的attack,不再使用父类的attack,且不会影响父类
        Hero.attack(self,enemy) #调用功能
        print(‘from riven‘)
    def fly(self): #在自己这里定义新的
        print(‘%s is flying‘ %self.nickname)

r1=Riven(‘锐雯雯‘,57,200,‘比基尼‘)
r1.fly()
print(r1.skin)

‘‘‘
运行结果
锐雯雯 is flying
比基尼

‘‘‘

class People:　　　　#定义父类
    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex
    def walk(self):
        print(‘%s is walking‘ %self.name)

    def foo(self):
        print(‘from father %s‘ %self.name)
class Teacher(People):　　　　#继承父类
    def __init__(self,name,age,sex,level,salary):　　　　#新建__init__方法
        People.__init__(self,name,age,sex)　　　　#还使用父类的方法
        self.level = level　　　　　　　　　　　　　 #新增的内容
        self.salary = salary
    def tech(self):　　　　　　　　　　　　　　　　#子类特有的函数属性
        print(‘%s is teaching ‘ %self.name)

    def foo(self):
        People.foo(self)
        print(‘from Teacher‘)　　　　　　　　　　#对父类的函数属性引用和新增
class Student(People):
    def __init__(self,name,age,sex,group):
        People.__init__(self,name,age,sex)
        self.group = group
    def study(self):
        print(‘%s is studying‘%self.name)
t=Teacher(‘egon‘,18,‘male‘,10,3000)
print(t.salary)
t.tech()
t.foo()
‘‘‘
3000
egon is teaching
from father egon
from Teacher

‘‘‘

5、组合与与重用性

软件重用的重要方式除了继承之外还有一种方式，即：组合。

组合指的是，在一个类中以另外一个类的对象作为数据属性，称为类的组合。

class Date:　　　　#定义一个关于日期的类
    def __init__(self,year,mon,day):
        self.year = year
        self.mon = mon
        self.day = day
    def tell_birth(self):
        print(‘出生于%s年 %s月 %s日‘%(self.year,self.mon,self.day))
class Teacher:　　　　#定义一个老师的类
    def __init__(self,name,age,year,mon,day):
        self.name = name
        self.age = age
        self.birth = Date(year,mon,day)　　　　#使用Date的类
    def teach(self):
        print(‘%s is teaching‘%self.name)

t=Teacher(‘egon‘,18,1990,12,11)
t.birth.tell_birth()
‘‘‘
出生于1990年 12月 11日
‘‘‘

组合与继承都是有效地利用已有类的资源的重要方式。但是二者的概念和使用场景皆不同。

5.1 继承的方式

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

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

>>> class Teacher:
...     def __init__(self,name,gender):
...         self.name=name
...         self.gender=gender
...     def teach(self):
...         print(‘teaching‘)
...
>>>
>>> class Professor(Teacher):
...     pass
...
>>> p1=Professor(‘egon‘,‘male‘)
>>> p1.teach()
teaching

5.2 组合的方式

用组合的方式建立了类与组合的类之间的关系，它是一种‘有’的关系,比如教授有生日，教授教python课程。

class BirthDate:
    def __init__(self,year,month,day):
        self.year=year
        self.month=month
        self.day=day

class Couse:
    def __init__(self,name,price,period):
        self.name=name
        self.price=price
        self.period=period

class Teacher:
    def __init__(self,name,gender):
        self.name=name
        self.gender=gender
    def teach(self):
        print(‘teaching‘)
class Professor(Teacher):
    def __init__(self,name,gender,birth,course):
        Teacher.__init__(self,name,gender)
        self.birth=birth
        self.course=course

p1=Professor(‘egon‘,‘male‘,
             BirthDate(‘1995‘,‘1‘,‘27‘),
             Couse(‘python‘,‘28000‘,‘4 months‘))

print(p1.birth.year,p1.birth.month,p1.birth.day)
print(p1.course.name,p1.course.price,p1.course.period)
‘‘‘
运行结果:
1 27
python 28000 4 months
‘‘‘

二、接口与归一化设计

1、什么是接口

继承有两种用途：

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

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

class File:　　　　  #定义接口File类来模仿接口的概念。
    def read(self): #定接口函数read
        pass

    def write(self): #定义接口函数write
        pass

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

    def write(self):
        print(‘文本数据的读取方法‘)

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

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

class Process(File):
    def read(self):
        print(‘进程数据的读取方法‘)

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

#父类要限制
#1：子类必须要有父类的方法
#2：子类实现的方法必须跟父类的方法的名字一样
import abc

class File(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def read(self):
        pass

    @abc.abstractmethod
    def write(self):
        pass

class Txt(File): #文本，具体实现read和write
    def read(self):
        pass
    def write(self):
        pass
t=Txt()

实践中，继承的第一种含义意义并不很大，甚至常常是有害的。因为它使得子类与基类出现强耦合。

继承的第二种含义非常重要。它又叫“接口继承”。
接口继承实质上是要求“做出一个良好的抽象，这个抽象规定了一个兼容接口，使得外部调用者无需关心具体细节，可一视同仁的处理实现了特定接口的所有对象”——这在程序设计上，叫做归一化。

归一化使得高层的外部使用者可以不加区分的处理所有接口兼容的对象集合——就好象linux的泛文件概念一样，所有东西都可以当文件处理，不必关心它是内存、磁盘、网络还是屏幕（当然，对底层设计者，当然也可以区分出“字符设备”和“块设备”，然后做出针对性的设计：细致到什么程度，视需求而定）。

2、为何要有接口

接口提取了一群类共同的函数，可以把接口当做一个函数的集合。

然后让子类去实现接口中的函数。

这么做的意义在于归一化，什么叫归一化，就是只要是基于同一个接口实现的类，那么所有的这些类产生的对象在使用时，从用法上来说都一样。

归一化，让使用者无需关心对象的类是什么，只需要的知道这些对象都具备某些功能就可以了，这极大地降低了使用者的使用难度。

比如：我们定义一个动物接口，接口里定义了有跑、吃、呼吸等接口函数，这样老鼠的类去实现了该接口，松鼠的类也去实现了该接口，由二者分别产生一只老鼠和一只松鼠送到你面前，即便是你分别不到底哪只是什么鼠你肯定知道他俩都会跑，都会吃，都能呼吸。

再比如：我们有一个汽车接口，里面定义了汽车所有的功能，然后由本田汽车的类，奥迪汽车的类，大众汽车的类，他们都实现了汽车接口，这样就好办了，大家只需要学会了怎么开汽车，那么无论是本田，还是奥迪，还是大众我们都会开了，开的时候根本无需关心我开的是哪一类车，操作手法（函数调用）都一样