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)


    #組合