1.依賴關係

類與類之間存在這幾種關係:1.依賴關係 2.關聯關係 3.組合關係 4.聚合關係 5.繼承關係 6.實現關係

 我們來設定下面兩個場景 玩電腦和打殭屍

class Person:
    def play(self, tools): # 通過引數的傳遞把另外一個類的物件傳遞進來
        tools.run()
        print("很開心, 我能玩兒遊戲了")


class Computer:
    def run(self):
        print("電腦開機. 可以執行")

class Phone:
    def run(self):
        print("手機開機, 可以執行")


c = Computer()
phone = Phone()

p = Person()
p.play(phone)



# 寫一個植物大戰殭屍
# 1. 植物
#       打殭屍. 殭屍掉血
# 2. 殭屍
#       吃植物. 植物掉血

class Plant:
    def __init__(self, name, hp, ad): # 200
        self.name = name
        self.hp = hp
        self.ad = ad

    def attack(self, js):
        print("植物攻擊殭屍")
        js.hp -= self.ad
        print(f"殭屍掉血{self.ad}, 還剩下{js.hp}")

class JiangShi:
    def __init__(self, name, hp, ad): # 1000  800
        self.name = name
        self.hp = hp
        self.ad = ad

    def attack(self, zw):
        print("殭屍咬植物")
        zw.hp -= self.ad
        print(f"植物掉血{self.ad}, 還剩{zw.hp}")


# 植物
wd = Plant("歪脖子豌豆", 10, 20)
# 殭屍
js = JiangShi("鐵桶殭屍", 200, 1)
wd.attack(js)
wd.attack(js)
wd.attack(js)
wd.attack(js)
wd.attack(js)

js.attack(wd)
js.attack(wd)
js.attack(wd)
js.attack(wd)
 

2.關聯關係,組合關係,聚合關係

這三個在程式碼上寫法是一樣的,但是,從含義上是不一樣的

1.關聯關係:兩種事物必須是互相關聯的.但是在某種情況下是可以更改和更換的

2.聚合關係.屬於關聯關係中的一種特例.側重點是xxx和xxx聚合成xxx.各自有各自的宣告週期.比如電腦,電腦有cpu,硬碟,記憶體等等.電腦壞了,cpu還是好的,還是完整的個體.

3.組合關係.屬於關聯關係中的一中特例.寫法上差不多.組合關係比聚合還要緊密,比如人的大腦,心臟,各個器官,這個器官組合成一個人.這是人如果掛了.其他的東西也就失效了

我們舉個例子,男人關聯著女朋友,女人關聯著男朋友.這種關係可以是互相的

class Boy:

    def __init__(self, name,  girlFriend=None):
        # 在初始化的時候可以給一個物件的屬性設定成另一個類的物件
        self.girlFriend = girlFriend  # 一個男孩有一個女朋友

    def chi(self):
        if self.girlFriend:
            print(f"帶著他的女朋友{self.girlFriend.name}去吃飯")
        else:
            print("單身狗, 吃什麼吃? 滾去學習.")

    def movie(self):
        if self.girlFriend:
            print(f"帶著他的女朋友{self.girlFriend.name}去看電影")
        else:
            print("單身狗, 看什麼看? 滾去學習.")


class Girl:
    def __init__(self, name):
        self.name = name

b = Boy("小明")
g = Girl("小紅")
b.chi()

# 給小名介紹一個女朋友 小紅
b.girlFriend = g
b.chi()

g2 = Girl("小紅")
b.girlFriend = g2 # 換了個女朋友
b.chi()


class School:

    def __init__(self, name):
        self.teach_list = [] # 這裡要裝多個老師
        self.name = name

    def zhaopin(self, teach):
        self.teach_list.append(teach)

    def shangke(self):
        for t in self.teach_list:
            t.work()

class Teacher:
    def __init__(self, name):
        self.name = name
    def work(self):
        print(f"{self.name}在上課")

lnh = School("小學")
t1 = Teacher("王老師")
t2 = Teacher("趙老師")
t3 = Teacher("錢老師")
t4 = Teacher("孫老師")
t5 = Teacher("李老師")
t6 = Teacher("周老師")

lnh.zhaopin(t1)
lnh.zhaopin(t2)
lnh.zhaopin(t3)
lnh.zhaopin(t4)
lnh.zhaopin(t5)
lnh.zhaopin(t6)

lnh.shangke()
 

1.一對一關係 只有一個女朋友  2.一對多關係  一個學校,一堆老師

3.繼承關係,self

self:誰呼叫的就是誰.型別是根據呼叫方的物件來進行變換的,self在訪問方法的順序,永遠先找自己的.自己找不到再找父類的

super:表示的是父類

4.類中的特殊成員

__init__ :      建構函式，在生成物件時呼叫,類名()會自動執行
__del__ :       解構函式，釋放物件時使用
__repr__ :      列印，轉換
__setitem__ :   按照索引賦值
__getitem__:    按照索引獲取值
__len__:        獲得長度
__cmp__:        比較運算
__call__:       呼叫
__add__:        加運算
__sub__:        減運算
__mul__:        乘運算
__div__:        除運算
__mod__:        求餘運算
__pow__:        冪
__call__          物件()會自動執行
__getitem__   物件[key]會自動執行
__setitem__    [key]=value會自動執行
__delitem__         del物件[key]會自動執行
__enter__  和__exit__      with物件as變數會自動執行
__str__            列印物件的時候會自動執行 
__hash__  == None 物件就不可雜湊了

__init__()就是一個特殊的成員.這些方法在特殊的場景的時候會被自動執行

類名()會自動執行__init__()
def __init__(self): # 初始化操作
       print("我是init,  我是老二")
       print("初始化操作. 在建立物件的時候自動呼叫這個方法")

　def __new__(cls, *args, **kwargs): # 建立, 它是真正的構造方法, 可以開闢記憶體
 　　  print("我是new. 我是老大")
          return object.__new__(cls)

物件()會自動執行__call__()

def __call__(self, *args, **kwargs):
        print("我是物件()")

物件[key]會自動執行__getitem__()

 # 物件[]
 def __getitem__(self, item):
      print("item=",item)
      print("你執行了__getitem__")
      return "哈哈"

del 物件[key]會自動執行__delitem__()

del lst[1]
     def __delitem__(self, key):
          print("key=", key)

with物件as變數 會自動執行__enter__和__exit__

# with 物件:
def __enter__(self):
   print("我是enter")

# with 物件: 程式碼執行完畢. 最後執行這裡
def __exit__(self, exc_type, exc_val, exc_tb):
   print("我叫exit")

列印物件的時候會自動執行__str__

class Student:
    def __init__(self, name, no, gender, cls, age):
        self.name = name
        self.no = no
        self.gender = gender
        self.cls = cls
        self.age = age


    # 這個物件字串的表示.
    def __str__(self): # 返回該物件的字串表示形式
        return f"{self.name}, {self.no}, {self.gender}"

    def __repr__(self): # 該物件的官方的字串表示形式
        return f"{self.name}, {self.no}, {self.gender}"


s = Student("小名", "3", "男", "三年二班", "31")
print(s)
幹掉可雜湊__hash__ == None 物件就不可雜湊了

面向物件程式設計的執行流程 ->
1. 載入類 -> 給類建立一個名稱空間 -> 主要存放類變數.
2. 建立物件 -> 先找類. -> 根據類來開闢記憶體 -> 執行類中的__new__() -> 執行__init__() -> 返回物件