day25继承的多态思想

==========================三大函数的数据结构=================================
    1.面向对象设计和面向对象编程：《1》使用类来描述一类的事物《2》
    2.小结
    3.类和对象
        3.1类相关 类有数据属性和函数属性
        3.2对象相关 对象只有数据属性
        3.3
==========================具体见下面代码=====================================
    4.静态属性，类方法，静态方法
        #静态属性
        #将函数属性转化为数据属性  需要本身self才能调用
        @property #将函数属性转化为数据属性
        
        #类方法,类调用的函数属相
        @classmethod #专门被类调用的函数属性  需要cls能调用
        
        #静态方法,类的工具包，不和类绑定也不和实例绑定,
        #名义上归市实例管理，但是实际上是不适用类变量和实例变量，是类的工具包
        @staticmethod

        #组合
        #进行类之间的拼接

        #三个类，老师，学校，课程

    5.当类之间很对显著不同，并且较小的类是较大的类所需的组件时，用组合较好
    6.当类之间很多相同的功能，提取这些共同的功能，做继承

    7.继承同时具有两种特性
        继承：延续原来有的代码
        派生：产生新的行为
        含义一：继承基类的方法，并且做出自己的扩展和修改（代码重用）
        含义二：声明某个子类兼容于某基类，定义一个接口类，子类继承接口类，并且实现接口中定义的方法

        含义一意义并不大，甚至是常常有害的，因为他是的子类和基类出现强耦合
        继承的第二种含义非常重要，他又叫‘接口继承’

        接口继承实际上是要求‘做出一个良好的抽象’，接口继承必须要实现什么方法，这个抽象规定啦一个兼容接口，让外部调用者无需关心细节，可以一视同仁的处理实现了接口的所有的对象======这在程序上叫做归一化设计
==========================super方法的使用====================================
    class Vehicle:
        Country='China'
        def __init__(self,name,speed,load,power):
            self.name=name
            self.speed=speed
            self.load=load
            self.power=power

        def run(self):
            print('开动啦from Vechile')
    class Subway(Vehicle):
        def __init__(self,name,speed,load,power,line):
            super().__init__(name,speed,load,line)
            # self.name=name
            # self.speed=speed
            # self.load=load
            # self.power=power
            # self.line=line
            #实例化和对象调用的时候才会自动传递self
            Vehicle.__init__(self,name,speed,load,power)
            self.line=line
        def show_info(self):
            #super().__init__()
            #Vehicle.run(self)
            print(self.name,self.speed,self.line)
        def run(self):
            #super().run()#方式一
            #super(Subway,self).run()#方式二
            print('%s %s线,开动啦'%(self.name,self.line))
    line13=Subway('北京地铁','180km/h',100000,'电',13)
    line13.show_info()
    line13.run()
==========================子类中调用父类=====================================
    class Vehicle:
        Country='China'
        def __init__(self,name,speed,load,power):
            self.name=name
            self.speed=speed
            self.load=load
            self.power=power

        def run(self):
            print('开动啦from Vechile')
    class Subway(Vehicle):
        def __init__(self,name,speed,load,power,line):
            super().__init__(name,speed,load,line)
            # self.name=name
            # self.speed=speed
            # self.load=load
            # self.power=power
            # self.line=line
            #实例化和对象调用的时候才会自动传递self
            Vehicle.__init__(self,name,speed,load,power)
            self.line=line
        def show_info(self):
            #super().__init__()
            #Vehicle.run(self)
            print(self.name,self.speed,self.line)
        def run(self):
            super().run()
            print('%s %s线,开动啦'%(self.name,self.line))
    line13=Subway('北京地铁','180km/h',100000,'电',13)
    line13.show_info()
    line13.run()
==========================接口继承===========================================
    import abc
    class Allfile(metaclass=abc.ABCMeta):

        #基类不需要实例化，规定子类必须实现父类的方法
        @abc.abstractmethod
        def read(self):
            pass
        @abc.abstractmethod
        def write(self):
            pass
    class Disk(Allfile):
        def read(self):
            print('disk read')
        def write(self):
            print('disk write')
    class Cdrom(Allfile):
        def read(self):
            print('cdrom read')
        def write(self):
            print('cdrom write')
    class Mem(Allfile):
        def read(self):
            print('mem read')

    m1=Mem()
    #接口就是函数
    #TypeError: Can't instantiate abstract class Mem with abstract methods write
    #子类没有实现继承父类的方法导致实例初始化失败
    m1.write()
==========================组合的使用=========================================
    class Hand():
        pass
    class Foot():
        pass
    class Trunk():
        pass
    class Head():
        pass

    class Person():
        def __init__(self,id_num,name):
            self.id_num=id_num
            self.name=name
            self.hand=Hand()
            self.foot=Foot()
            self.trunk=Trunk()
            self.head=Head()
    class School():
        def __init__(self,name,addr):
            self.name=name
            self.addr=addr
            print('from School')
        def zhao_sheng(self):
            print('正在招生')
    class Course():
        def __init__(self,name,price,period,school):
            self.name=name
            self.price=price
            self.period=period
            self.school=school
    s1=School('old','南京')
    s2=School('old','南京')
    s3=School('old','南京')
    # c1=Course('linux',10,'1h',s1)
    # print(c1.school)
    msg='''
    1.老男孩 北京校区
    2.老男孩 南京校区
    3.老男孩 东京校区
    '''

    while True:
        menu={
            '1':s1,
            '2':s2,
            '3':s3,
        }
        choice=input('选择学校--->>>：')
        school_obj=menu[choice]
        name=input('输入课程名：')
        price=input('输入价格：')
        period=input('课程周期：')
        new_course=Course(name,price,period,school_obj)
        print('课程【%s】属于【%s】学校'%(new_course.name,new_course.school.name))
==========================继承===============================================
    class Dad():
        '这是一个爸爸类'

        money=10
        def __init__(self,name):
            print('爸爸')
            self.name=name

        def hit_son(self):
            print('%s 正在打儿子'%self.name)

    class Son(Dad):

        money = 100000000
        def __init__(self,name,age):
            self.name=name
            self.age=age



    s1=Son('oulne')
    print(s1.money)
    print(Dad.money)
    print(Dad.__dict__)
    print(Son.__dict__)
==========================继承的顺序==========================================
    # -*- coding: utf-8 -*-
    class A(object):
        def test(self):
            print('a')
    class B(A):
        def test(self):
            print('b')
    class C(A):
        def test(self):
            print('c')
    class D(B):
        def test(self):
            print('d')
    class E(C):
        def test(self):
            print('e')
    class F(D,E):
        # def test(self):
        #     print('f')
        print('来之A')
    f1=F()
    f1.test()
    print(F.__mro__)#(<class '__main__.F'>, <class '__main__.D'>, <class '__main__.B'>, <class '__main__.E'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)
    #深度优先
    #广度优先
    #1.经典类：class A：,class B(A)
    #2.新式类 class A(object),class B(A)
    #1.经典类  深度优先  一直找到最后的基类
    #2.新式类  广度优先   一直找到基类，但是不包括最后的基类
==========================静态属性============================================
    class Room:
        tag=1
        def __init__(self,name,owner,width,length,height):
            self.name=name
            self.owner=owner
            self.width=width
            self.length=length
            self.height=height
        @property #将函数属性转化为数据属性
        def cal_area(self):
            return self.width*self.length
            #print('%s 住的 %s 总面积是%s' % (self.owner, self.name, self.width * self.length))
        @classmethod #专门被类调用的函数属性
        def tell_info(cls,x):
            print('from test',cls.tag)
            print('from cls.tag',cls.tag,x)
    r1=Room('厕所','alex',100,100,1000000)
    r2=Room('公共厕所','yuehao',1,1,2)
    # print('%s 住的 %s 总面积是%s'%(r1.owner,r1.name,r1.width*r1.length))
    # print('%s 住的 %s 总面积是%s'%(r2.owner,r2.name,r2.width*r2.length))
    # r1.cal_area
    # r2.cal_area


    # print(r1.cal_area)
    # print(r2.cal_area)
    # print(r1.name)
    # print(r2.name)
    # print(Room.tag)
    # print(Room.tag)
    #类调用函数属性，和自己的函数是有捆绑的
    r3=Room('厕所','alex',100,100,1000000)
    Room.tell_info(10)

    #类属性不能调用对象属性
    r3.tell_info(11)
    print(r3.__dict__)
==========================静态属性，类方法，静态方法============================
    class Room:
        tag=1
        def __init__(self,name,owner,width,length,height):
            self.name=name
            self.owner=owner
            self.width=width
            self.length=length
            self.height=height
        #静态属性
        #将函数属性转化为数据属性  需要本身self才能调用
        @property #将函数属性转化为数据属性
        def cal_area(self):
            return self.width*self.length
            #print('%s 住的 %s 总面积是%s' % (self.owner, self.name, self.width * self.length))


        #类方法,类调用的函数属相
        @classmethod #专门被类调用的函数属性  需要cls能调用
        def tell_info(cls,x):
            print('from test',cls.tag)
            print('from cls.tag',cls.tag,x)#Room.tag


        #静态方法,类的工具包，不和类绑定也不和实例绑定,
        #名义上归市实例管理，但是实际上是不适用类变量和实例变量，是类的工具包
        @staticmethod
        def wash_body(a,b,c):
            print('%s %s %s正在洗澡'%(a,b,c))
        # def test(x,y):
        #     print(x,y)

    #Room.wash_body('a','b','b')
    r1=Room('厕所','alex',100,100,1000000)
    print(Room.__dict__)#static 是存放在类的属性里面
    r1.wash_body('a','b','b')
    print(r1.__dict__)
    # Room.test()
    # r1.test(1,2)

    # r1=Room('厕所','alex',100,100,1000000)
    # r2=Room('公共厕所','yuehao',1,1,2)


    #组合