初识python： 继承

继承：可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。

　　通过继承创建的新类称为“子类”或“派生类”。

　　被继承的类称为“基类”、“父类”或“超类”。

　　继承的过程，就是从一般到特殊的过程。

　　要实现继承，可以通过“继承”（Inheritance）和“组合”（Composition）来实现。

在某些 OOP 语言中，一个子类可以继承多个基类。但是一般情况下，一个子类只能有一个基类，要实现多重继承，可以通过多级继承来实现。

继承概念的实现方式主要有2类：实现继承、接口继承。

         实现继承：使用基类的属性和方法而无需额外编码的能力；

         接口继承：仅使用属性和方法的名称、但是子类必须提供实现的能力(子类重构父类方法)；

* 注：在考虑使用继承时，两个类之间的关系应该是“属于”关系。例如，“学生”是一个人，“老师” 也是一个人，因此这两个类都可以继承 “人”这个 类。但是 “腿”这个类却不能继承 “人”这个类，因为“腿”并不是一个人。

 

抽象类仅定义由子类创建的一般属性和方法。

OOP开发范式大致为：划分对象→抽象类→将类组织成层次化结构(继承和合成) →用类与实例进行设计和实现几个阶段。

实例：

仅继承，不做任何其他事。

# class People  经典类写法
# 经典类与新式类的主要区别在继承方式
class People(object):  # 新式类写法
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def eat(self):
        print('%s正在吃东西。'%self.name)

    def sleep(self):
        print('%s正在睡觉。'%self.name)

# 仅继承，不做任何其他事
class Man(People):  # 继承父类 People
    pass

m1 = Man('simple',25)
m1.eat()
m1.sleep()

继承在做一些自己的事。

# class People  经典类写法
# 经典类与新式类的主要区别在继承方式
class People(object):  # 新式类写法
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def eat(self):
        print('%s正在吃东西。'%self.name)

    def sleep(self):
        print('%s正在睡觉。'%self.name)

# 继承，在做一些自己的事
class Man(People):  # 继承父类 People
    def learning(self):
        print('%s正在学习。'%self.name)

m1 = Man('simple',25)
m1.eat()
m1.learning()

重构父类: 继承，并给父类增加功能（重构父类）：先执行父类，在执行子类。（父类和子类都含有相同名称的函数）

# class People  经典类写法
# 经典类与新式类的主要区别在继承方式
class People(object):  # 新式类写法
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def eat(self):
        print('%s正在吃东西。'%self.name)

    def sleep(self):
        print('%s正在睡觉。'%self.name)

# 重构父类: 继承，并给父类增加功能（重构父类）：先执行父类，在执行子类
class Man(People):  # 继承父类 People
    def learning(self):
        print('%s正在学习。'%self.name)

    def sleep(self):
        People.sleep(self)
        print('子类要做一些事。')
m1 = Man('simple',25)
m1.sleep()  # 先执行父类sleep，返回：simple正在睡觉。 在执行子类sleep，返回：子类要做一些事。

一个父类同时被多个子类继承

# class People  经典类写法
# 经典类与新式类的主要区别在继承方式
class People(object):  # 新式类写法
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def eat(self):
        print('%s正在吃东西。'%self.name)

    def sleep(self):
        print('%s正在睡觉。'%self.name)

# 定义第一个子类
class Man(People):  # 继承父类 People
    def learning(self):
        print('%s正在学习。' % self.name)
    def sleep(self):
        People.sleep(self)
        print('子类要做一些事。')

# 定义第二个子类
class Woman(People):
    def sing(self):
        print('%s在唱歌'%self.name)

m1 = Man('simple',25)
m1.sleep()  # simple正在睡觉。 # 子类要做一些事。

w1 = Woman('simgirl',25)
w1.sing()

重构父类，增加子类传入参数个数。

# class People  经典类写法
# 经典类与新式类的主要区别在继承方式
class People(object):  # 新式类写法
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def eat(self):
        print('%s正在吃东西。'%self.name)

    def sleep(self):
        print('%s正在睡觉。'%self.name)

# 重构父类，增加子类传入参数的个数
class Man(People):  # 继承父类 People
    def __init__(self,name,age,money):
        # People.__init__(self,name,age)  # 经典写法，如果更改了父类名称，此处也需要更改
        super(Man,self).__init__(name,age)  # 形式写法，建议使用此方法。因为，如果更改了父类名称，此处不需要更改
        self.money = money
        print('%s的初始金额为：%s'%(self.name,self.money))
    def learning(self):
        print('%s正在学习。' % self.name)
    def sleep(self):
        People.sleep(self)  # 执行父类方法
        print('子类要做一些事。')

m1 = Man('simple',25,100)
m1.sleep()
m1.eat()

多继承

# 第一个父类
class People(object):
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def eat(self):
        print('%s正在吃东西。'%self.name)

# 第二个父类
class Relation(object):
    def meak_friends(self,obj):
        print('%s和%s在搞对象。'%(self.name,obj.name)) #  name 从People继承，在实例化的时候生成。

class Man(Relation,People):
    pass

class Woman(People, Relation):
    pass

m1 = Man('simple',25)
w1 = Woman('simgirl',25)

m1.meak_friends(w1)
w1.meak_friends(m1)

继承方式：

　　python2 经典类按深度优先继承，新式类按广度优先。
　　python3 都是按照广度优先继承。

class A:
    def __init__(self):
        print('a')

class B(A):
    pass
    def __init__(self):
        print('b')

class C(A):
    def __init__(self):
        print('c')

class D(B,C):
    pass
    def __init__(self):
        print('d')

d1 = D()  # 执行顺序，广度优先：D -> B -> C -> A  # python2执行顺序，深度优先：D -> B -> A