组合与类继承

# 组合：自定义类的对象作为另外一个类的属性
class Teacher:
    def __init__(self,name,age):
        self.name = name
        self.age= age
t1=Teacher('bob',17)
class Student:
    def __init__(self,name,age,teacher):
        self.name =name
        self.age = age
        self.teacher = teacher
stu =Student('xiao ming',18,t1)
print(stu.teacher.name)
print(stu.__dict__)
print(stu.teacher.__dict__)
#继承：将所有的共有的属性与方法抽离出，形成父类
#父类是多个有共同点的普通类抽离出属性与方法形成的类
class People:
    def __init__(self ,name):
        self.name = name
    def eat(self):
        print(self.name+'在吃饭')
class Student(People):
    identify = '学生'
class Teacher(People):
    identify = '老师'
class Leader(People):
    identify = '领导'
stu = Student('bob')
print(stu.name)
print(stu.identify)
stu.eat()
tea = Teacher('owen')
print(tea.name)
print(tea.identify)
tea.eat()
lead = Leader('YANG')
print(lead.name)
print(lead.identify)
lead.eat()
#继承语法：
#class 类名（父类名）：pass
class A:
    pass
print(A.__bases__)#(<class 'object'>,)
print(Student.__bases__)#(<class '__main__.People'>,)
print(Student.identify)#父类没有，其他类就没有，有的都是自身的
print(Leader.identify)
print(Teacher.identify)

#继承的信息
class Sup:
    __num = 10
    def __init__(self,name):
        self.__name = name
    @property
    def name (self):
        print(123)
        return self.__name
    @classmethod
    def __c_fn(cls):
        print(cls,'c fn')

    def __o_fn(self):
        print('o fn')
class Sub(Sup):
    def test(self):
        print(self)
        print(self.__name)
print(Sub._Sup__num)
print(Sub('bob').name)
Sub(18)._Sup__c_fn()
Sub(18)._Sup__o_fn()#以上除了接口外都是非正常调用

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


#方法的重写
#有继承关系的属性查找顺序如下：
#1.优先找自身，自身没有找父类
#2.父类没有找父类的父类
#3.一直找到最顶级的父类，如果还没有报错


class Sup:
    num = 10
    def test(self):
        print('test sup')
class Sub(Sup):
    num=10
    #先写好父类的方法，由于父类的方法功能不满足子类需求
    #子类可以重写父类方法：方法名与父类相同，自定义方法的实现体

    def test(self):
        print('test sub')

print(Sub.num)
Sub().test()

#方法的重用
class Sup:
    pass
    #重用：还需要父类的功能，在父类方法功能基础上再添加新功能
    #突破点：在子类中去调用父类的方法，还有保证调用者是子类（子类的对象）
    def test(self):
        print('>>sup',self)
        print('test sup')
class Sub(Sup):
    def test(self):
        super().test()
        #python3简化了，
        # super（Sub，self）.test()  在python2中
        print('test sub')
        print('>>sub',self)
        print('test sub')
Sub().test()

#super与__init__
#人类：初始化——name
#老师：初始化——name salary
#学生：初始化——name grade
class Sup:
    def test(self):
        print(self)

    def __init__(self,name):
        self.name = name
class Sub(Sup):
    #有继承关系关系下，只要名字相同 ，即使产生不同，还是属于同一个方法
    def test(self,num):
        super().test()
        print(num)
    def __init__(self,name,salary):
        super().__init__(name)
        self.salary = salary
#Sub().test(10)
Sub('bob',19).test(1)

#简单的多继承
#属性的查找顺序：优先找自己的，如果没有，按照继承先后查找父级
class A:
    name = 'A'
    num=10
class B:
    name = 'B'
    count = 100
class C(A,B):
    name = 'C'
print(C.num)
print(C.count)
print(C.name)
print(C.mro())#打印查找顺序
#复杂的多继承
class A:
    name ='A'
class B(A):
    name = 'B'
class C:
    name = 'C'
class D(C):
    name = 'D'
class E(B,D):
    name = 'E'
print(E.mro())
#菱形是先广再深度 python3
class G: name = 'G'
class C(G): pass
class B(C):pass
class E(G):pass
class D(E):pass
class F(G):pass
class A(B,D,F):pass
print(A.mro())