目錄

• 1.繼承:顧名思義 拿來吧你 依法接受
• • 1.1多繼承
• 2.多態:不明顯 不需要繼承
• 3.各種方法
• • 3.1實例方法
  • 3.2類方法
  • 3.3靜態方法

1.繼承:顧名思義 拿來吧你 依法接受

# 面向對象三個特征:封裝、繼承、多態
# 封裝在一個類中 用的時候 實例化 對象名=類() 方法 屬性
# 生活中：子女繼承父母的基因 子女繼承父母的財產
# 面向對象中：子類繼承父類的屬性和方法 兒子 父親有錢
# 單繼承 多繼承
# 作用: 實現代碼的重用，相同的代碼不需要重復編寫
# 兩個類
# 動物類：吃 睡
# 狗類：吃 睡 跑 叫
# 封裝 寫 動物類 狗類 動物類 吃睡跑叫
class Animal:
def eat(self):
print('動物有吃的方法')
def sleep(self):
print('動物有睡的方法')
#不寫吃和睡 繼承
class Dog(Animal):
def run(self):
print('動物有跑的方法')
def bark(self):
print('動物有叫的方法')
# 可以 正常邏輯
ergou=Dog()
ergou.eat()
ergou.sleep()
ergou.run()
ergou.bark()
# 繼承可以直接享用父類的方法，不需要再次開發
# 子類按照自己的需求，封裝自己的方法
# 擴展專業術語
# Dog類是Animal類的 子類 Animal類是Dog類的父類 Dog類從Animal類 繼承
# Dog類是Animal類的派生類 Animal類是Dog類的基類 Dog類從Animal類進行派生
# 狗類下面可以還有子類嗎？可以有子類
# 繼承可以一直繼承下去
# A-B-C-D d具有所有父類的特征 單繼承
class Animal:
def eat(self):
print('動物有吃的方法')
def sleep(self):
print('動物有睡的方法')
#不寫吃和睡 繼承
class Dog(Animal):
def run(self):
print('動物有跑的方法')
def bark(self):
print('動物有叫的方法')
class GodDog(Dog):
def fly(self):
print('嘯天狗會飛')
# 哮天犬具有了所有父類的特征
xtq = GodDog()
xtq.eat()
xtq.sleep()
xtq.run()
xtq.bark()
xtq.fly()
class CommonDog(Dog):
def catch(self):
print('會抓老鼠')
# 問題:定義一個普通狗繼承狗類 普通狗會有哪些方法?
# 除了會飛都有
# 沒有會飛是為什麼？沒有繼承 Dog類 2個兒子 1個兒子 天狗 1個兒子 普通狗
pt = CommonDog()
pt.run()
pt.sleep()

1.1多繼承

# 能擁有兩個爸爸嗎? 多繼承 有一個爸爸 有一個媽媽
# 可以多繼承,子類可以擁有多個父類，並且具有父類所有的屬性和方法
# 多繼承 類名(父類，父類）
class A:
def demoA(self):
print('這是父類A的方法')
class B:
def demoB(self):
print('這是父類A的方法')
class C(A,B):
def demoC(self):
print('這是父類A的方法')
c=C()
c.demoA()
c.demoB()
c.demoC()
# 項目中不會使用多繼承
# 如果說用了多繼承 那我會以哪個為主
# 你爸爸會縫衣服，你媽媽也會縫衣服 想要繼承縫衣服 先繼承你爸爸縫衣服的技術 還是你媽媽
# 我現在想學蛋糕技術，一個是拜人家為師，學習人家祖傳秘方
# 另外一個 去培訓學校培訓蛋糕技術
class Master:
def __init__(self):
self.peifang = '師傅的蛋糕配方'
def make_cake(self):
print(f'使用{
self.peifang}技術')
class School:
def __init__(self):
self.peifang = '學校的蛋糕配方'
def make_cake(self):
print(f'使用{
self.peifang}技術,學習蛋糕')
class Tudi(Master,School):
pass
# 是以哪個配方為主 師傅 就近
xiaxia = Tudi()
xiaxia.make_cake()
# 結論: 一個類繼承多個父類，會優先繼承第一個類的屬性和方法
# 隨著時間的流逝，徒弟蛋糕就學會了。自己創新了一個蛋糕技術。徒弟他也有制作蛋糕的方法了
class Master:
def __init__(self):
self.peifang = '師傅的蛋糕配方'
def make_cake(self):
print(f'使用{
self.peifang}技術')
class School:
def __init__(self):
self.peifang = '學校的蛋糕配方'
def make_cake(self):
print(f'使用{
self.peifang}技術,學習蛋糕')
class Tudi(Master,School):
def __init__(self):
self.peifang='自己的蛋糕配方'
def make_cake(self):
print(f'使用{
self.peifang}技術，學習蛋糕')
xiaxia = Tudi()
xiaxia.make_cake()
# 結論:子類和父類擁有同名的方法和屬性，會覆蓋父類的方法和屬性
# 劇情繼續發展,徒弟學出來之後，自己開了一個店,結合三個口味推出了
# 師傅的配方拿出來,學校的配方拿出來，自己創建的配方拿出來 整出3個口味
# super()指向的是父類 拿到父類的屬性和方法
class Master:
def __init__(self):
self.peifang = '師傅的蛋糕配方'
def make_cake(self):
print(f'使用{
self.peifang}技術')
class School(Master):
def __init__(self):
self.peifang = '學校的蛋糕配方'
def make_cake(self):
print(f'使用{
self.peifang}技術,學習蛋糕')
super().__init__()
super().make_cake()
class Tudi(School):
def __init__(self):
self.peifang='自己的蛋糕配方'
def make_cake(self):
print(f'使用{
self.peifang}技術，學習蛋糕')
super().__init__()
super().make_cake()
xiaxia = Tudi()
xiaxia.make_cake()

2.多態:不明顯 不需要繼承

# 指的是同一類型的事物,有不同的形態
# 傳入不同的對象,產生不同的結果 動物都會吃 吃的東西不一樣
# 豬吃飯,貓吃貓糧,狗吃狗糧,動物都有吃的方法，干脆創建吃的方法
# 創建好的對象使用吃的方法 豬吃 貓吃 狗吃 吃的方法 不同的形態
class Pig:
def eat(self):
print('豬吃飯')
class Cat:
def eat(self):
print('貓吃貓糧')
class Dog:
def eat(self):
print('狗吃狗糧')
# 傳入不同對象
def eat(a):
a.eat()
p = Pig()
c = Cat()
d = Dog()
eat(p)
eat(c)
eat(d)
# 可以往方法裡面傳入一個類對象
# 調用不同類對象的相同方法名，產生不同的結果
class Dog:
def __init__(self,name):
self.name = name
def work(self):
print('看守家門')
class BigDog(Dog):
def work(self):
print('抓小偷')
class SmartDog(Dog):
def work(self):
print('緝毒')
class Person:
def with_dog(self,obj):
print('警員和%s一起去--'%(obj.name))
obj.work()
xiaoqi = BigDog('神犬小七')
erha = SmartDog('二哈')
p = Person()
p.with_dog(xiaoqi)
#調用不同類對象的相同方法名，產生不同的結果

3.各種方法

# 方法裡面可以傳入對象進去
# 類方法:實例方法 靜態方法
# 實例方法：類中的函數帶有self
# 類方法:需要用到@classmethod裝飾，參數命名cls
# 靜態方法：需要用到@staticmethod裝飾,參數沒有self也沒有cls 參數
class Stu:
school = '測碼課堂'
def __init__(self,name,age):
self.name = name
self.age = age
# 實例方法
def play_ball(self):
print(f'{
self.name}打籃球')
@classmethod
def sport(cls):
print(f'{
cls.school}的同學都喜歡打羽毛球')
# 靜態方法內部裡面沒有用到類相關的內容，可以把這個函數定位成靜態方法
# 定義成靜態方法可以不用對象.方法名。可以類.方法名
# 靜態方法要求，你想要把你的普通方法定義成靜態方法，要求你的這個方法，不要去引用到外部的東西
@staticmethod
def clean():
print('打掃衛生')

3.1實例方法

# 對象名.方法名() 類.方法名(對象名)
stu1 = Stu('cxk',18)
stu1.play_ball()
Stu.play_ball(stu1)

3.2類方法

# 類方法: 對象名.方法名() 類.方法名
# 你的整個類都可以擁有的一個方法，可以設計成類方法
stu1 = Stu('cxk',18)
stu1.sport()
Stu.sport()

3.3靜態方法

# 不會訪問類的任何屬性或其他方法，可以設計成靜態方法
Stu.clean()