面向对象——继承

1、什么是继承？

继承一种新建类的方式,新建的类称之为子类/派生类,被继承的类称之为父类基类超类

# 将所有共有的属性与方法抽离出，形成父类
# 父类是多个有共同点的普通类抽离共有属性与方法形成的类

2.python中继承的特点：

python中继承的特点:
        1. 子类可以遗传/重用父类的属性
        2. python中一个子类可以同时继承多个父类
        3. 在继承背景下去说,python中的类分为两种:新式类,经典类
            新式类: 但凡继承了object的类Foo,以及该类的子类...都是新式类
                在python3中一个类即便是没有显式地继承任何类,默认就会继承object
                即python3中所有的类都是新式类

            经典类:没有继承object的类,以及该类的子类...都是经典类
                在python2中才区分新式类与经典类,
                在python2中一个类如果没有显式地继承任何类,也不会继承object

3 为何要用继承
    减少类与类之间代码冗余

3 如何用继承

# 继承的规则
# 1.父类的所有未封装的属性和方法，子类都能访问
# 2.父类的所有封装的属性和方法，子类都不能访问
#       -- 在外界通过子类或子类对象，不能访问
#       -- 在子类内部通过子类或子类对象也不能访问

语法

# class Parent1(object):
#     pass
#
# class Parent2(object):
#     pass
#
# class Sub1(Parent1):
#     pass
#
# class Sub2(Parent1,Parent2):
#     pass

# print(Parent1.__bases__)
# print(Parent2.__bases__)
# print(Sub1.__bases__)
# print(Sub2.__bases__)

3.1利用继承来解决代码之间的冗余问题
例子

class OldboyPeople:
    school = 'Oldboy'

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

class OldboyStudent(OldboyPeople):
    # def __init__(self, name, age, sex, score=0):
    #     self.name = name
    #     self.age = age
    #     self.sex = sex
    #     self.score = score

    def choose_course(self):
        print('%s choosing course' % self.name)

class OldboyTeacher(OldboyPeople):
    # def __init__(self,name,age,sex,level):
    #     self.name=name
    #     self.age=age
    #     self.sex=sex
    #     self.level=level

    def score(self,stu,num):
        stu.score=num


stu1=OldboyStudent('刘二蛋',38,'male')
print(stu1.__dict__)

tea1=OldboyTeacher('egon',18,'male')
print(tea1.__dict__)

3.2 父类功能的重用

在子类派生出的新方法中重用父类功能的方式一:

# 指名道姓地引用某一个类中的函数
# 总结:
# 1. 与继承无关
# 2. 访问是类的函数,没有自动传值的效果

class OldboyPeople:
    school = 'Oldboy'

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

class OldboyStudent(OldboyPeople):
    def __init__(self, name, age, sex, score=0):
        OldboyPeople.__init__(self,name,age,sex)
        self.score = score

    def choose_course(self):
        print('%s choosing course' % self.name)

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

    def score(self,stu,num):
        stu.score=num


stu1=OldboyStudent('刘二蛋',38,'male')
print(stu1.__dict__)

tea1=OldboyTeacher('egon',18,'male',10)
print(tea1.__dict__)

在子类派生出的新方法中重用父类功能的方式二:super()必须在类中用
 

class Sup:
    def __init__(self, name):
        self.name = name

    def test(self):
        print(self)


class Sub(Sup):
    # 默认父级的__init__可以被继承过来，
    # 但是会出现子类对象的属性比父类多
    def __init__(self, name, salary):
        super().__init__(name)  # 父级有的共性功能通过super()交给父级做
        self.salary = salary  # 子类特有的自己来完成

    # 有继承关系下，只要名字相同，即使参数不同，还是属于同一个方法
    def test(self, num):
        super().test()  # 使用父级的方法
        print(num)

# 外界通过Sub对象来调用test方法，一定找自己的test方法(属性的查找顺序)


# 重点：super() 可以得到调用父级功能的对象，调用者还是子类对象
# 		-- super()只能在子类的方法中使用
#		-- super()本质 super(子类类名, 当前对象)
#		-- super().父类普通方法 | super().__init__() | super()能调用父类所有可继承方法

# 在python2中:super(自己的类名,自己的对象)
# 在python3中:super()
# 调用该函数会得到一个特殊的对象,该对象专门用来访问父类中的属性,!!!完全参照mro列表!!!!
# 总结:
# 1. 严格依赖继承的mro列表
# 2. 访问是绑定方法,有自动传值的效果

# class OldboyPeople:
#     school = 'Oldboy'
#
#     def __init__(self,name,age,sex):
#         self.name = name
#         self.age = age
#         self.sex = sex
#
# class OldboyStudent(OldboyPeople):
#     def __init__(self, name, age, sex, score=0):
#         super(OldboyStudent,self).__init__(name,age,sex)
#         self.score = score
#
#     def choose_course(self):
#         print('%s choosing course' % self.name)
#
# class OldboyTeacher(OldboyPeople):
#     def __init__(self,name,age,sex,level):
#         super().__init__(name,age,sex)
#         self.level=level
#
#     def score(self,stu,num):
#         stu.score=num


# stu1=OldboyStudent('刘二蛋',38,'male')
# print(stu1.__dict__)
#
# tea1=OldboyTeacher('egon',18,'male',10)
# print(tea1.__dict__)

4.单继承背景下的属性的查找
     在单继承背景下属性的查找优先级:对象->对象的类->父类->父类.....

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

    def f2(self):
        print('Foo.f2')
        self.f1() #obj.f1()

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

obj=Bar()
obj.f2()
'''
Foo.f2
Bar.f1
'''

5

# 在多继承背景下属性的查找优先级:
# 如果一个子类继承多个分支(多个分支没有共同继承一个非object的类)
# 此时属性的查找优先级是:对象->对象的类->按照从左往右的顺序一个分支一个分支的找下去

# # 第四层:
# class G:
#     # x = 'G'
#     pass
#
# # 第三层
# class E(G):
#     # x = 'E'
#     pass
#
# class F:
#     # x = 'F'
#     pass
#
# # 第二层
# class B(E):
#     # x = 'B'
#     pass
#
# class C(F):
#     # x = 'C'
#     pass
#
# class D:
#     # x = 'D'
#     pass
#
# # 第一层
# class A(B, C, D):
#     # x = 'A'
#     pass
#
# obj = A()
# # obj.x = 111
# print(obj.x)

#菱形继承问题:
# 新式类 : 广度优先查找,从左往右一个分支一个分支的查找,在最后一个分支才去查找顶级类
# 经典类 : 深度优先查找,从左往右一个分支一个分支的查找,在第一个分支就查找顶级类

class G(object):
    # x = 'G'
    pass

# 第三层
class E(G):
    # x = 'E'
    pass

class F(G):
    # x = 'F'
    pass

# 第二层
class B(E):
    # x = 'B'
    pass

class C(F):
    # x = 'C'
    pass

class D(G):
    # x = 'D'
    pass

# 第一层
class A(B, C, D):
    # x = 'A'
    pass


obj=A()
# obj.x=111
print(obj.x)
#新式类(广度优先): obj->A->B->E->C-F->D->G->object
#经典类(深度优先): obj->A->B->E->G->C-F->D

# python专门为新式类内置了一个mro的方法,用来查看c3算法的计算结果,结果是??
print(A.mro())