DAY23、面向对象特性

一、复习
1、类：
    对象属性的查找顺序：先找自身再找类
    类的名称空间：直接写在类中
    对象的名称空间：写在__init__方法中，通过self.属性形成名称空间中的名字
    类的方法：在类中用@classmethod装饰的方法，第一个参数一定接收类，建议只拿类调用
    对象的方法：在类中定义的普通方法，第一个参数一定接收对象，建议只拿对象调用
2、封装：对外隐藏属性与方法的实现细节，类的内部均可以直接访问__名字
    方式：在属性或方法前用__修饰，将__名字更名为_类名__名字
    作用：有些属性或方法只提供给内部使用，所以采用封装处理
    对象属性的封装，对外提供接口
        @property
        def id(self):
            return self.__id
        @id.setter
        def id(self,id):
            seif.__id = id
        @id.deleter
        def id(self):
            del self.__id
二、组合
自定义类的对象作为另外一个类的属性
class Teacher:
    def __init__(self,name,age):
        self.name = name
        self.age = age

    t1 = Teacher('Bom',18)
    print(type(t1.name),type(t1.age))

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

stu = Student('Tom',18,t1)
print(stu.__dict__)
print(stu.teacher.name)
print(stu.teacher.age)

三、继承
1、将所有共有的属性与方法抽离出，形成父类
    父类是多个有共同点的普通类抽离共有属性与方法形成的类
    继承：子类与父类形成的一种关系，可以让子类能直接从父类中获取属性与方法
    优点：减少代码冗余
    两个名词：
        先写子类：抽离 出父类 (先有多个有共同点的类，抽离出共性的形成的类)
        先写父类：派生 出子类 (通过已有的父类，再去定义该类的子类)
2、语法
    class People:
        def __init__(self,name):
            self.name = name
        def eat(self):
            print(self.name + '在吃饭')

    class Student(People):
        identify = '学生'

    student = Student('Bob')
    student.eat()

    class Teacher(People):
        pass

    class Leader(People):
        pass

3、属性与方法的继承
    父类所有未封装的属性和方法都可以被继承：
        父类的所有未封装的属性和方法，子类都能访问
        父类的所有封装的属性和方法，子类都不能访问
            在外界通过子类或子类对象，不能访问
            在子类内部也不能访问

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

        @property
        def name(self):
            return self.__name

        @classmethod
        def __c_fn(cls):
            print(cls,'c fn')

        def __o_fn(self):
            print(self.name,'o fn')

    class Sub(Sup):
        def test(self)；
            print(self)
            print(self.__name)
        pass

    print(Sub.num)                       #不能被访问
    Sub.c_fn()                           #不能被访问
    sub = Sub('Bob')
    print(sub.name)                      #Bob
    sub.o_fn()                           #不能被访问
    sub.test()                           #不能被访问 因为内部不能访问__name

4、有父类时的属性（方法）查找顺序：
    优先找自身，自身没有找父类
    父类没有找父类的父类
    一直找到最顶级的父类，如果还没有就报错

5、方法的重写：
    先写好父类的方法，由于父类的功能不满足子类需求
    子类可以重写父类的方法：方法名与父类相同，自定义方法的实现体
    class Sup:
        num = 10

        def test(sef):
            print('test sup')

    class Sub(self):
        num = 100

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

    print(Sub.num)               #100 优先查找自己的
    Sub().test()                 #test sub

6、方法的重用：
    重用：还需要父类方法的功能，在父类方法功能基础上再添加新功能
    突破点：在子类中去调用父类的方法，还有保证调用者是子类（子类的对象）
    class Sup:
        def test(self):
            print('>>>sup',self)
            print('test sup')

    class Sub(sup):
        pass

        def test(self):
            super().test()                  #python2中写法 super(Sup,self).test()
            print('>>>sub',self)
            print('test sub')

    Sub().test()

7、__init__结合super()
    class Sup:
        def test(self):
            print(self)

        def __init__(self,name)
            self.name = name

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

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

    Sub('Bob',15000).test(10)
    Sub().test()          #使用还是使用自身带参的，不能使用父级不带参的（本质名字相同就是一个，优先查找自己的）

8、多继承
    简单的多继承：
        属性的查找顺序：优先找自己的，如果没有，按照继承先后查找父级
        子类可以继承所有父类的所有可继承属性
        class A:
            name = 'A'
            num = 10

        class B:
            name = 'B'
            count = 100

        class C(A,B):
            pass             #自己=》A=》B

    复杂的多继承：
        class A:
            name = 'A'

        class B(A):
            name = 'B'

        class C:
            name = 'C'

        class D(C):
            name = 'D'

        class E(B,D):
            name = 'E'   #E=>B=>A=>D=>C
    菱形继承：
        经典类：python2中才有，没有继承任何类的类
        新式类：python2中没有直接或间接继承object的类（python3中没有明确继承关系的类默认继承object），
                python中所定义的所有类
        深度优先，在查找第一个分支查找到底
        广度优先，菱形的头在所有分支查找接收后再被查找
        通过 类.mro()查看继承顺序图