面向对象之继承

继承

　　是一种关系，必须存在两个对象产生这种关系，继承的一方称之为子，被继承的称为父

　　通过继承，可以直接使用父类提供的代码

　　怎样继承：在子类中的类名后面加括号，加上父类名称  例： calss Student(Teacher):

　　　　　　　python 中一个子类可以有多个父类，用逗号隔开，其他语言不支持多个父类

　　　　　　　子类  -------(访问）--------> 父类属性和方法（函数）

# 继承
1. 全部继承
class Teacher:
　　pass
class Student(Teacheer)
　　pass
Student 继承了Teacher所有的属性和方法

2. 抽取公共的父类，抽象
　 公共父类：抽取多个类中共同部分形成另一个类

class People:   # 抽取共同的部分
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def sayhello(self):
        print('hello, I am %s, my age is %s'%(self.name,self.age))

class Teacher(People):
   pass
class Student(People):
    pass

t1 = Teacher('jack',18)
t1.sayhello()
s1 = Student('david',12)
s1.sayhello()

总结： 继承避免了重复代码的编写
　　　　抽取： 避免继承到一些不应该有的内容
　　　　先抽取，后继承
　　　　公共父类： 存储子类相同属性和技能

派生和覆盖
派生： 子类继承某个父类，并且拥有自己独特的属性或技能
　　　　子类中出现了新内容----> 派生类
子类 ： 与父类完全一样，没有任何独特的内容

覆盖：如果子类中出现与父类相同的方法或属性（优先查子类）

class People:
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def sayhello(self):
        print('hello, I am %s, my age is %s'%(self.name,self.age))

class Teacher(People):

   def sayhello(self):
       print('hello, i am teacher %s'%self.name)


t1 = Teacher('jerry',18)
t1.sayhello() # 优先查找子类

结果为：hello, i am teacher jerry

# 子类访问父类的方法
很多情况下，子类与父类仅有一小部分不同，这时候子类仅需编写一小步与父类不同的代码，其他调用父类中已有的方法
调用父类方法：

第一种：使用类名直接调用，该方式与继承没有关系，指名道姓直接调用
第二种： 使用super()  相当于创建了一个对象，用来调用父类方法
　　　　　super()会按照mro继续往后查找

class People:
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def sayhello(self):
        print('hello, I am %s, my age is %s'%(self.name,self.age))

class Student(People):
    def __init__(self,name,age,studentID):
        People.__init__(self, name, age)  #方法一：通过类名调用时，要传入对象
        super().__init__(name,age)  # 方法二：super（）表示创建了一个特殊的对象，用来调用父类方法
        self.studentID = studentID

    def sayhello(self):
        print('i am a teacher')
        super().sayhello()    # 调用父类sayhello()方法

stu1 = Student('egon',18,2011014276)
stu1.sayhello()
结果为：

i am a teacher
hello, I am egon, my age is 18

 存在继承关系的属性查找

对象本身的名称空间---> 类的名称空间 ----> 父类的名称空间 ----> 父类的父类名称空间  ----> object 类

例：class D(A,B,C)        ------>   class A(E)

深度查找：先找A，然后E。。。B, C

--------------------------------------------------------------------------------------------------------------------------------------

菱形继承： 存在公共父类，会产生菱形继承

E（A,B,C,D）    A(F)    B(G)    C(H)    D(I)

E--> A-->F-->B-->G-->C-->H-->D-->I    --> 公共父类

按先深度优先，再广度优先，最后公共父类

该方法 按C3算法得来

--------------------------------------------------------------------------------------------------------------------------------------

新式类： 所有直接继承或间接继承object的类

object： 有个类叫object  ，内部有内置的特殊函数（object 是所有类的父类，称为根类，所有类的源头）

　　　　目的： 所有类源自object，因为创建对象时，需要申请内存空间，创建新的名词空间，将对象的

　　　　　　　属性放入名名称空间，这一系列复杂的基础操作都又object完成

　　　　　　　简单来说，object提供了一些常用的基础操作

总结： 所有类都属于新式类（python3 中）

经典类：不会自动继承object     class Student(object):  手动添加object类 （python2 中才有经典类）

类名.__bases__   用来查看父类   python 2 中 结果为  （）

　　　　　　　　　　　　　　　python 3 中结果　 (<class 'object'>,)　　

类名. mro()   --->  显示属性的查找顺序列表　　

总结： 当类是经典类（python2中）时，菱形属性查找 按深度查找

　　　当类是新式类（python3中），（菱形）属性查找按先深度，再广度，最后共同父类　　　　

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

　

class Equip:
    def fire(self):
        print('release Fire skill')

class Riven:
    camp = 'Noxus'

    def __init__(self,nickname):
        self.nickname = nickname
        self.equip = Equip()  # Equip() 产生一个对象，赋值给equip属性

r1 = Riven('riven')
r1.equip.fire()   # r1.equip 是 Equip 的一个对象，调用fire 方法
结果为：release Fire skill