類的應用場景（重要運用補充）類的組合繼承

```#
##1、什么是面向對象編程？
    以前是用函數
        現在是類+對象

##2、什么是類，什么是對象，他們又有什么關系？
    把函數放進類里
        class 類：
             def  foo(self):
                         pass
                    def  too(self):
                         pass
        obj是對象，是實例化后就得到一個對象（實例）                      
    obj=類()
        obj.foo()

##3、什么時候適合用面向對象？
1、根據一個模板創建東西的時候（cs里人的模板創建警察和劫匪）
2、多個函數傳入多個相同參數或者多個函數里有相同操作時

##4、self就是調用當前方法的對象
     #公有屬性應用場景：每個對象中保存相同的東西時，可以使用公有屬性
         class foo:
                    #靜態字段
                        #公有屬性
                        countey=“中國” #創建的每一個對象都有共同的值，就能設置成公有屬性
                        def __init__(self,city,count):
                            #普通字段
                                #普通屬性（在每個對象都保存著自己的那一份）
                             self.city=city
                                 self.count=count
                        des bar(self):
                              pass

                        obj1=foo("上海",200000)
                        obj1.bar()

                        obj2=foo("蘇州",1000000)
                        obj2.bar()

##5、什么是封裝？
     類中封裝了：字段、方法
         對象中封裝了：普通字段的值

         class f1:
             def  __init__(self,a):
                 self.a=a
                 print("f1")

         class f2:
             def  __init__(self,arge1):
                 self.b=arge
                 print("f2")

         class f3:
             def  __init__(self,arge2):
                 self.c=arge2
                 print("f3")

    o1=f1("alex")
    02=f2(o1)
    o3=f3(o2)
    想輸出“alex”
#o3=f3(o2)
   o3.c==>02

#o2=f(o1)
  o3.c=f(o1)
  o2.b==>o1

    o1=f1("alex")
    o3.c.b.a

##繼承

 class f1:
             def  __init__(self):
                    print("f1")
                 def a1(self):
                    print("f1a1")
                    def a2(self):
                    print("f1a2")

 class f2(f1):
             def  __init__(self):
                    print("f2")
                 def a1(self):
                     self.a2()
                    print("f2a1")
                    def a2(self):
                    print("f2a2")

    class f3(f2):
             def  __init__(self):
                    print("f3")
                 def a1(self):
                    print("f3a1")
         def a2(self):
                    print("f3a2")

            obj=f3()
            obj.a1()
            #輸出   f3a2 
                        f2a1
            obj傳進去，self.a2=obj.a2=f3.a2
![](https://cache.yisu.com/upload/information/20200310/57/120670.jpg?x-oss-process=image/watermark,size_16,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_100,g_se,x_10,y_10,shadow_90,type_ZmFuZ3poZW5naGVpdGk=)!

##6、靜態方法
      字段：普通字段(保存在對象中)
                       靜態字段（保存在類中）

            方法：普通方法（保存在類中，調用者是對象，至少有一個self參數）
            calss fff:
                   def  __init__(self,name)
                            self.name=name
                        def a1(self):
                             print(self.name)

                    obj=fff()
                    obj.a1()  #值已經保存在對象中了，對象有用。

            ##當你的方法和對象里的值沒有任何關系時這樣調用浪費空間 
            calss fff:
                        def a1(self):
                             print(“alex”)

                    obj=fff()
                    obj.a1() 

            ##此時應用靜態方法
            靜態方法（保存在類中，調用者是類，可以有任意個參數）:
                             calss fff:
                                  @staticmethod
                                      def a1(): #self不是必須的了
                                           print(“alex”)

                                fff.a1() #不需要創建對象直接調用就行

## 類的繼承中有（繼承，組合2種方式）
class School(object):
    """"學校成員基類"""
    number=0
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex
        self.enroll() #在基類里內部調用（相當于子類默認調用）

    def enroll(self):
        """注冊"""
        print("%s歡迎加入我們學院！"%self.name)
        School.number+=1 #把值賦給公有屬性(變成全局的)直接self.number只是在實例里面創建了一個變量number=0然后加1
    def tell(self):
        """打印自己的信息"""
        print("------info:%s-------"%self.name)
        for k,v in self.__dict__.items():
            print("\t",k,v)
        print("------end-------" )

    #def __del__(self):  # 析構
        print("[%s] 被開除了！"%self.name)
        School.number-=1

class newschool(object):
    def openschool(self,addr):
        print("open in the %s"%addr)

class Teacher(School,newschool): # 多繼承（繼承多個類）
    """講師類"""
    def __init__(self,name,age,sex,salary,course):
        #School.__init__(self,name,age,sex) #經典類
        super(Teacher,self).__init__(name,age,sex) # 新式類
        self.salary=salary
        self.coures=course

    def teaching(self):
        print("Teacher [%s] is teaching [%s]"%(self.name,self.coures))

class Student(School):
    """學生類"""
    def __init__(self,name,age,sex,course,fee,ttt):
        # School.__init__(self,name,sex,age)
        super(Student,self).__init__(name,age,sex)
        self.Teacher=ttt #類的繼承組合繼承模式
        self.course=course
        self.fee=fee
        self.amount=0

    def pay_fee(self,amount):
        print("student [%s] has just paid [%s]"%(self.name,self.amount))
        self.amount+=amount
#t=Teacher()
t1=Teacher("王肖",29,'F*M',20000,"Python")
s1=Student("王鼎",26,"N/A",'Python',30000,t1)
s2=Student("蘇曉",22,"F","Python",5000,t1)
print(s1.Teacher.salary) #類的繼承組合調用