Python的面向对象的三大特性之继承

class Parent1:
    pass
class Parent2:
    pass
class Sub1(Parent1): # 单继承
    pass
class Sub2(Parent1,Parent2): # 多继承
    pass

# 查看子类调用的父类
print(Sub1.__bases__) # (,)
print(Sub2.__bases__) # (, )

单继承：继承表达的是一种什么“是”什么的关系
  人类
  动物类
  共同的特点：吃，睡，跑，叫，也就是说人是动物
多继承：就不能像单继承那样，一个事物不能同时是多个事物，逻辑冲突

class A:
    pass
class B(A):
    x = 222
class C(B):
    pass
class D(C):
    pass

print(D.x) # 222 先去D找，再去C找，再去B找

# ps1：在python2中有经典类和新式类之分
# 新式类：继承了object类的子类，以及该子类的子类
# 经典类：没有继承object类的子类，以及该子类的子类子子类
# 总结：object类是python内置的类，也就是所有类的超类
"""
>>> class Foo:  # 经典类
...     pass
...
>>> Foo.__bases__
()
>>> class Bar(object):  # 新式类
...     pass
...
>>> Bar.__bases__
(,)
>>>
"""
# ps2:在python3中有没有经典类和新式类之分?
#       在python3之中没有继承任何类，那么会默认继承object类，所以python3中所有的类都是新式类
print(Parent1.__bases__)  # (,)
print(Parent2.__bases__)  # (,)

# 所以思考如何让python3中的类在python2中兼容？加入（object）
class Parent3(object):  # 兼容python2
    pass

class Parent4:
    x = 1
class Sub4(Parent4):
    y = 2

print(Sub4.x,Sub4.y) # 1 2

# 思考一下找到学生和老师的共同之处：
# 示范1：基于类与类之间存在冗余问题

# 选课系统
# 定义学生类
class Student:
    school = ‘OLDBOY‘
    # 定义学生属性
    def __init__(self,stu_id,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex
    # 定义学生功能
    def choose_course(self):
        print(‘%s 正向选课‘ % self.name)

# 定义老师类
class Teacher:
    school = ‘OLDBOY‘

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

    def score(self):
        print(‘老师 %s 正在给学生打分‘ % self.name)

# 派生的三种情况：新建，修改，扩展

# 提取出共有的属性
class OldboyPeople:
    school = ‘OLDBOY‘
    # 定义共有属性
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex

# 选课系统
# 定义学生类
class Student(OldboyPeople):

    # 派生之一：新建一个功能
    def choose_course(self):
        print(‘%s 正向选课‘ % self.name)

    # 派生之二：修改
    school = ‘派生之二修改OLDBOY学校名‘

# 实例话学生
stu_obj = Student(‘lili‘,18,‘female‘)
print(stu_obj.__dict__)  # {‘name‘: ‘lili‘, ‘age‘: 18, ‘sex‘: ‘female‘}
print(stu_obj.school)  # 派生前OLDBOY 派生后运行结果：派生之二修改OLDBOY学校名
stu_obj.choose_course()  # lili 正向选课

"""
    对象本身,lsj‘,18,‘male‘,3000,2
init中(self,name,age,sex,salary,level)
"""
class Teacher(OldboyPeople):
    # 派生之三：扩展
    def __init__(self,name,age,sex,salary,level):
        # 指名道姓的跟父类要init这个方法（name,age,sex）
        OldboyPeople.__init__(self,name,age,sex)
        self.salary = salary
        self.level = level

    def score(self):
        print(‘老师 %s 正在给学生打分‘ % self.name)

tea_obj = Teacher(‘lsj‘,18,‘male‘,3000,2)
# 派生之三前运行结果：TypeError: __init__() takes 4 positional arguments but 6 were given

print(tea_obj.__dict__)
# 派生之三后运行结果：{‘name‘: ‘lsj‘, ‘age‘: 18, ‘sex‘: ‘male‘, ‘salary‘: 3000, ‘level‘: 2}

print(tea_obj.school)  # OLDBOY
tea_obj.score()  # 老师 lsj 正在给学生打分

# 单继承背景下的属性查找
# 示范一
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
# 为什么是这样的结果：不是就近查找

# 单继承背景下的属性查找
# 需求必须调用Foo类下的f1该怎么办？
# 示范一
class Foo:
    def f1(self):
        print(‘Foo.f1‘)
    def f2(self):
        print(‘Foo.f2‘)
        Foo.f1(self) # 调用当前类中的f1，运行结果：Foo.f1
        self.f1()  # obj.f1()

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

obj = Bar()
obj.f2()
# 运行结果：Foo.f2  Bar.f1
# 为什么是这样的结果：不是就近查找

# 示范二 
class Foo:
    # 使用隐藏属性
    def __f1(self):   # _Foo__f1
        print(‘Foo.f1‘)
    def f2(self):
        print(‘Foo.f2‘)
        self.__f1()  # self._Foo__f1

class Bar(Foo):
    def __f1(self):  # _Bar__f1
        print(‘Bar.f1‘)

obj = Bar()
obj.f2()
# 运行结果：Foo.f2  Foo.f1