面向对象三大特性——继承（含派生）

继承概念

继承指的是类与类之间的关系，继承的功能之一就是可以用来解决代码重用问题。
　　1、继承是一种创建新类的方式

　　2、在python中，新建的类可以继承一个或多个父类（其他语言只能继承一个父类），父类又可以称为基类或者超类

　　3、新建的类称为派生类或子类。

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

class ParentClass1:
    pass

class ParentClass2:
    pass

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

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

查看继承: __bases__

__base__：只查看从左到右继承的第一个子类
__bases__：查看所有继承的父类

print(ParentClass1.__base__, type(ParentClass1.__base__))
print(SubClass1.__base__, type(SubClass1.__base__))
print(SubClass2.__base__, type(SubClass2.__base__))   # 只查看到第一个父类
"""
<class 'object'> <class 'type'>
<class '__main__.ParentClass1'> <class 'type'>
<class '__main__.ParentClass1'> <class 'type'>
"""

print(SubClass1.__bases__)
print(SubClass2.__bases__)
"""数据结构为元组
(<class '__main__.ParentClass1'>,)
(<class '__main__.ParentClass1'>, <class '__main__.ParentClass2'>)
"""

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

经典类：在Python2中，没有显式继承object类的类，以及该类的子类都是经典类。

新式类：python2中，显式地声明继承object类，以及该类的子类都是新式类。

　　需要注意的是仅在python2中才分新式类和经典类，在python3中，无论是否继承object，都默认继承object，即python3中所有类均为新式类。

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

抽象定义即抽取类似或者说比较像的部分（也就是提取一类事物的特点，范围越来越大，共性越来越少）。
抽象分为两个层次：
1、将奥巴马和梅西者俩对象比较像的部分抽取成类；
2、将人，猪，狗这三个类比较像的部分抽取成父类。
抽象最主要的作用是划分类别（可以隔离关注点，降低复杂度），
继承：是基于抽象的结果，通过编程语言去实现它，肯定是先经历抽象这个过程，才能通过继承的方式去表达出抽象的结构。
抽象：只是分析和设计的过程中，一个动作或者说一种技巧，通过抽象可以得到类。

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

    def attack(self, enemy):
        enemy.life_value -= self.aggresivity

class Garen(Hero):
    pass

class Riven(Hero):
    pass

g1 = Garen('刚哥', 29, 30)
print(g1.__dict__)
"""
{'nickname': '刚哥', 'life_value': 29, 'aggresivity': 30}
"""

继承与重用性

　　开发程序的过程中，如果我们定义了一个类A，然后又想新建立另外一个类B，但是类B的大部分内容与类A的相同时：

　　可以通过继承的方式新建类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 move_forward(self):
        print('%s move forward' %self.nickname)

    def move_backward(self):
        print('%s move backward' %self.nickname)

    def move_left(self):
        print('%s move forward' %self.nickname)

    def move_right(self):
        print('%s move forward' %self.nickname)

    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) #结果:300
r1.attack(g1)
print(g1.life_value) #结果:243

代码重用示例

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

属性查找

　　子类有自己的方法，就执行自己的；如果子类没有自己的方法，就会找父类的。

class Foo:
    def f1(self):
        print('from Foo.f1')

    def f2(self):
        print('from Foo.f2')
        self.f1()


class Bar(Foo):
    def f2(self):
        print('from Bar.f2')

b = Bar()
print(b.__dict__)  # 未定义__init__没有自己的属性  字典内为空
b.f1()   # 指向父类的函数
b.f2()   # 指向子类重用的函数
"""
{}
from Foo.f1
from Bar.f2   # 注意和父类中的区别
"""

派生

派生概念

　　1、在父类的基础上产生子类，产生的子类就叫做派生类

　　2、父类里有，子类也有的方法，就叫做方法的重写（就是把父类里的方法重写）

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

　　3、父类里没有的方法，在子类中有了，这样的方法就叫做派生方法。

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
比基尼

'''

面向对象三大特性——继承（含派生）

猜你喜欢