類的應用場景（重要運用補充）

#
##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

!``

##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() #不需要創建對象直接調用就行