组合，多态，封装

1.组合
    1.什么是组合
        组合指的是某一个对象的属性是另外一个类的对象
        class Foo：
            pass
        class Bar：
            pass
        obj1=Foo（）
        obj2=Bar()
        obj1.xxx=obj2
        obj1.xxx.x相当于obj2.x的内容


    2.为什么要用组合(也是用来解决类与类之间代码冗余的问题)
        通过为某一个对象添加属性（属性的值是另一个类的对象）的方式 可以间接的将两个类关联/整合/组合
        到一起，从而减少类与类之间的代码冗余
        class Foo1：
            pass
        class Foo2：
            pass
        class Foo3：
            pass
        obj1=Foo1()
        obj2=Foo2()
        obj3=Foo3()
        obj1.attr1=obj_from_bar
        obj2.attr2=obj_from_bar
        obj3.attr3=obj_from_bar





    3.如何要用组合
        class Foo1：
            def coss2():
            pass
        class Foo2：
            def coss():
            pass
        py1=Foo1()
        py2=Foo2(xxx)
        py1.coss2=py2




2.多态与多态性
    2.1 什么是多态
        多态指的是同一种类食物的不同形态，

    2.2 为何要用多态
        多态性：在多态的背景下，可以在不用考虑对象具体类型的前提下而直接使用对象
        多态性的精髓：统一


    2.3 如何要用多态
        import abc
        class Animal(metaclass=abc.ABCMeta):
            @abc.abstractclassmethod
            def speak(self):
                pass
        #Animal()父类值是用来建立规范的，不能用来实例化的，更无需实现内部方法
        class People(Animal):
            def speak(self):
                print("people")

        class Dog(Animal):
            def speak(self):
                print("dog")

        class Pig(Animal):
            def speak(self):
                print("pig")
        obj1=People()
        obj2=Dog()

        #pythom崇尚鸭子类型
        class Memory:
            def read(self):
                print("Memory")

        class Disk:
            def read(self):
                print("Memory")
        obj1=Disk()
        obj2=Memory()
        obj1.read()
        obj2.read()



3.封装
    3.1 什么是封装？
        装：往容器/名称空间里存入名字
        封：代表的是将容器内的属性隐藏起来
        注意：这种隐藏是对内不对外的



    3.2 为何要封装？
        如何做到“封”：在属性命前加上__开头，特点如下：
            1.__开头的属性会在检测语法的时候发生变形，规则_类名__属性名
            2.这种隐藏是对内不对外的
            3.该变形只在语法检测的时候发生一次，在类定义之后新增的__开头的属性不会发生变形
            4.父类不想让子类覆盖自己的属性，可以在属性前加__开头

        封装不是单纯意义上的隐藏
            封数据属性：将数据属性隐藏起来，类外就无法直接操作属性，需要类内开辟一个接口来外部的使用可以间接
        操作属性，可以在接口内定义的任意控制逻辑，从而严格使用者对属性的操作。

            封函数属性：隔离复杂度


    3.3 如何封装
        在类内定义的属性前加__开头（没有__结尾）
        class Foo:
            __x=111
            def __init__(self,name,age):
                self.__name=name
                self.__age=age
            def __func(self):
                print("func")
            def get_info(self):
                print(self.__age, self.__x, self.__age)
        # print(Foo.__func)
        # print(Foo.__x)
        # print(Foo.__dict__)
        obj=Foo("egon",18)
        # print(obj.__name)
        obj.get_info()

总结：  #1. __开头的属性实现的隐藏仅仅只是一种语法意义上的变形，并不会真的限制类外部的访问

        #2. 该变形操作只在类定义的阶段检测语法时发生一次，类定义阶段之后新增的__ 开头的属性不会变形

        #3. 如果父类不想让子类覆盖自己的属性，可以在属性前加__开头

4.property装饰器
    #表示当前方法是一个属性，方法的返回值就是这个属性值

        @property # 查看
        def name(self): #方法只能有一个参数，self
            return 10 # 必须有返回值


    需要了解property的用法
        class People:
            def __init__(self,name,weight,height):
                self.name=name
                self.weight=weight
                self.height=height
            @property
            def bmi(self):
                return self.weight/(self.height**2)
        obj=People("yan",70,1.82)
        # obj.height=1.85
        print(obj.bmi)

    但凡是被property装饰器修饰过的必然会生成一个setter的装饰器

class nammm:
    def __init__(self,__name):
        self.__name=__name
    @property#查看
    def name(self):
        return "<%s>"%self.__name
    @name.setter#修改
    def name(self,new_name):
        self.__name=new_name
    @name.deleter#删除
    def name(self):
        del self.__name

调用：
jbk=nammm("yanhui")
print(jbk.name)
jbk.name=123
print(jbk.name)
del jbk.name
print(jbk.name)