（python）面向多对象的三大特性之（继承）

对象：特征与技能的结合体

类：一系列对象相同的特征与技能的集合体

    现实中的对象经过抽象成实现中的类，在代码中，通过类的调用，实例化出一个对象。

    类体代码在定义的时候就会立刻执行，产生类的名称空间，类名的名称空间用来存放属性，用点来调用这些属性，点的左这一定是一个类。

强调：

1、类中最常见的是变量与函数的定义,如果一个类有相似的技能与特征，就定义它，没有相似的就不用定义。

2、程序中的类并不完全等同于实现世界中的类。（策略类）

3、类相当于一个模板或工厂，通过调用类会产生对象（产生对象的名称空间，这个对象的名称空间可能引用类中名称空间的的变量名与函数名。）

__init__方法

1、该方法内可以用任意的Python 代码：

2、在该方法内一定不能有返回值

绑定方法

1、绑定给谁就由谁来调用，

2、谁来调用就把谁当作第一个参数来传入使用

一切皆对象：

python3中统一了类与类型的概念，类即类型

一、继承。

1）基本介绍：

1、什么继承？

继承是一种新建类的方式，在Python中支持一个儿子继承多个爹。

新建的类称为子类或者派生类，父类可以称为基类，或者是超类。

子类会‘遗传’父类的属性

2、为什么要用用继承？

 为了减少代码冗余。

3、怎么用继承

基本格式：

class Father1:
    pass
class Father2:
    pass
class Father3:
    pass

class Son1(Father1,Father2):
    pass

print(Son1.__bases__)

显示为：

  

2）如何寻找继承关系：

继承是类与类之间的关系，寻找这种关系需要先抽象再继承

class OldboyPerson:
    shcool = 'oldboy'

    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex

class OldboyTeacher(OldboyPerson):

    def change_socre(self):
        print('teacher %s is changing score'%self.name)

class OldboyStudent(OldboyPerson):

    def choose(self):
        print('student %s is choose course'%self.name)

t1=OldboyTeacher('EGON',18,'MALE')
s1=OldboyTeacher('monicx',18,'MALE')

基于继承再查看属性的查找：对象自己的名称空间==》对象的类名称空间==》对象类的父类名称空间。（这个顺序是固定的，不会就近找）

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

obj=Bar()
obj.f2()

结果为：

Foo.f2
Bar.f1

派生：子类定义自己新的属性，如果与父类同名，以子类自己的为准

class OldboyPerson:
    shcool = 'oldboy'

    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex

class OldboyTeacher(OldboyPerson):
    def __init__(self, name, age, sex,level,salary):
        self.name = name
        self.age = age
        self.sex = sex

        self.level=level
        self.salary=salary
    def change_socre(self):
        print('teacher %s is changing score'%self.name)

tea1=OldboyTeacher('ENGON',18,'MALE',9,5100)
print(tea1.name,tea1.age,tea1.sex,tea1.level,tea1.salary)

结果为：

ENGON 18 MALE 9 5100

我们发现子类当中有重复的代码，

在子类派生的新方法中重用父类的代码。

方式一：指名道姓地调用，与继承没关系：

class OldboyPerson:
    shcool = 'oldboy'

    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex

class OldboyTeacher(OldboyPerson):
    def __init__(self, name, age, sex,level,salary):
        # self.__init__(name,age,sex)#这样子还是调用自己，没用调父类，会报错。
        OldboyPerson.__init__(self,name,age,sex)
        self.level=level
        self.salary=salary
    def change_socre(self):
        print('teacher %s is changing score'%self.name)

tea1=OldboyTeacher('ENGON',18,'MALE',9,5100)
print(tea1.name,tea1.age,tea1.sex,tea1.level,tea1.salary)

方式二：super()调用（严格依懒于继承）

super()的返回值是一个特殊的对象，该对象专门调用交类中的属性。

class OldboyPerson:
    shcool = 'oldboy'

    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex

class OldboyTeacher(OldboyPerson):
    def __init__(self, name, age, sex,level,salary):
        super().__init__(name,age,sex)
        self.level=level
        self.salary=salary
    def change_socre(self):
        print('teacher %s is changing score'%self.name)

tea1=OldboyTeacher('ENGON',18,'MALE',9,5100)
print(tea1.name,tea1.age,tea1.sex,tea1.level,tea1.salary)

了解新式类与经典类

新式类：继承Object的类，以及该类的子类，都是新式类，在Python3当中，如果一个类没的指定继承的父类，都是默认继承Object类

经典类（只在在Python2中才有）：没有继承Object的类，以及该类的子类，都是经典类

它们的区别在于多继承的属性查找上。

多分支的情况下的一样的，都是每个分支走到头，再去另一条分支。

但在棱型的情况下，经典类是深度优先（多条分支第一条就直接走到头，然后去走接下来的分支），新式类就是广度优先（前面的分支不到头最后一条分支走到头）。

组合：

解决类与类之间代码冗余问题有两种解决方案：1、继承 2、 组合。

（继承描述的是类与类之间的从属关系。）

组合：是一种什么有什么的关系，一个类产生的对象，该对象拥有一个属性，这个属性的值是来自于另外一个类的对象。

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 OldboyPerson:
    shcool = 'oldboy'

    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex

class OldboyTeacher(OldboyPerson):

    def __init__(self,name,age,sex,level,salary):
        super().__init__(name,age,sex)
        self.level=level
        self.salary=salary

class OldboyStudent(OldboyPerson):

    def __init__(self,name,age,sex,course):
        super().__init__(name,age,sex)
        self.course=course

t1=OldboyTeacher('EGON1',18,'MALE',9,5100)
t1.birth=Date(2000,1,1)
t1.birth.tell_birth()

s1=OldboyStudent('MONICX',23,'MALE','PYTHON')
s1.birth=Date(1995,4,14)
t1.birth.tell_birth()

从上面的代码可以看出。一个OldboyTeacher类产生的s1，该对象拥有一个属性birth，这个属性的值是来自于另外一个Date类的对象。这就是组合的使用。