The Nature of Code閱讀心得與Python實作：4.6 Inheritance and...
這一節的標題是
4.6 Inheritance and Polymorphism
因為方格子標題字數限制，所以沒完整顯現
接下來，我們會藉由繼承(inheritance)和多型(polymorphism)這兩個物件導向程式設計的技術，來製作更多樣化、更有趣的粒子系統。
假設我們要寫程式製作一張電子賀卡，賀卡上面要撒滿紫色、粉紅色、星形、方形、快速翻轉、一閃一閃閃個不停等各式各樣五彩繽紛的碎紙花。這麼多具有不同外觀和行為的碎紙花，全都要一股腦兒顯示在螢幕上。
顯然現在我們面對的是一個由一個個碎紙花所構成的粒子系統。
面對這樣一個含有許多不同外觀和行為的粒子所構成的粒子系統，在設計Particle類別時，或許可以用不同的變數來存放粒子的顏色、形狀、行為等資料。有了這些變數之後，也許在製作實例(instance)時，可以利用亂數來決定這些變數的初始值，讓製作出來的Particle實例，具有各種不同的顏色、外觀、行為。不過，這種把所有用來產生各式各樣粒子的程式碼，全都給塞在同一個類別裡頭的做法，雖然可以達到目的，但如果不同粒子之間的差異很大，卻會讓程式碼非常的雜亂。
既然上面提到的做法不怎麼樣，那或許可以把一種粒子寫成一個類別，像這樣：
class HappyConfetti: ...
class FunConfetti: ...
class WackyConfetti: ...
然後在Emitter類別的__init__()中，利用亂數來決定要用哪一個類別來製作粒子，並把製作出來的粒子放進粒子系統中，像這樣：
class Emitter:
def __init__(self, num):
particles = []
for i in range(num):
r = random.random()
if r < 0.33:
self.particles.append(HappyConfetti())
elif r < 0.67:
self.particles.append(FunConfetti())
else:
self.particles.append(WackyConfetti())
到目前為止，一切都很順利，沒什麼問題，反正需要什麼樣的粒子，就寫個那種粒子的類別就是了。當然啦，在寫的時候，也不需要每行都重打，不同種類的粒子之間再怎麼不同，總有一些程式碼是一樣的，複製、貼上就可以了。不過，話雖這麼說，但寫程式的時候，刻苦耐勞、埋頭苦幹，可絕不是一種美德；寫程式的時候應該要時時刻刻想到，有沒有什麼更好的寫法，可以更有效率地達到目的。在這裡，我們應該要自問的是：我們真的要在不同的「confetti」類別間，不斷地複製、貼上一大堆的程式碼嗎？
不管粒子再怎麼不同，他們的類別的程式碼中，總會有許多部分是一樣的；像是記錄位置、速度、加速度的變數，還有更新狀態的update()方法等，在不同粒子的類別程式碼中，這部分的程式碼都是一樣的。既然如此，那有沒有什麼好辦法，可以省去這一大堆的複製、貼上工作呢？
繼承！繼承這個技術，就可以讓我們擺脫不斷複製、貼上的惡夢！利用繼承的方式，在設計新的類別時，就可以直接讓新的類別具備現有類別中的屬性和方法，而不需重複撰寫程式碼。這樣子，我們就可以專注於設計新的類別特有的功能。
利用繼承的方式，可以讓我們在設計新的粒子類別時省下不少功夫。不過，在面對一大堆不同種類的粒子時，先前所設計的Emitter類別，還能不能用呢？
先前在設計Emitter類別時，我們是把所有的粒子都存放在list中進行處理，而那些粒子都是同一類的粒子，處理方法都一樣。但是，現在我們要處理的粒子，卻有著不同的種類，那我們怎麼知道list中放的是哪種？而又該用哪個方法來處理？
這是一個挺嚴肅的問題，畢竟現在我們有許多不同種類的粒子，如果不知道要處理的是哪種粒子，那又怎麼會知道哪個方法適用？
那難不成要為每一種粒子準備一個list，然後每個list裡頭，就只放一種粒子？
這樣子做，雖然很明確可以知道放在list中的粒子是哪一種，然後找到合用的方法來處理，但實在是很不優。我們想要的做法，是就只用一個list來存放所有各式各樣不同類型的粒子，而且在處理的過程中，可以不用去辨識粒子的種類。這時候，就是多型這個技術派上用場的時候了。多型這個技術，就可以讓我們用同樣的方法來處理不同類型的物件。
知道問題之所在之後，接下來，我們會更詳細地來看看，關於繼承和多型這兩個技術的內容，並且利用這兩個技術來製作一個粒子系統。
Inheritance Basics
要說明繼承這個技術，動物的世界是個很好的例子。
動物世界中有貓、狗、猴子、松鼠、麻雀等等各式各樣的動物。我們先從狗開始。狗有年齡，會吃東西、會睡覺、會叫，所以狗的類別可以設計成這樣：
class Dog:
def __init__(self):
self.age = 0
def eat(self):
print("Yum!")
def sleep(self):
print("Zzzzzz")
def bark(self):
print("WOOF!")
接下來是貓。貓有年齡，會吃東西、會睡覺、會叫，所以貓的類別可以設計成：
class Cat:
def __init__(self):
self.age = 0
def eat(self):
print("Yum!")
def sleep(self):
print("Zzzzzz")
def meow(self):
print("MEOW!")
再來還有許許多多不同的動物，都要這樣一個一個的寫。其實，如果仔細看一下這些程式碼就會發現，大部分都是一模一樣的。即使用複製、貼上的方式可以省下不少功夫，但一直不斷地重複同樣的動作，實在是讓人厭煩又沒有效率。那有沒有什麼其他比較好的方法呢？當然有！用繼承的方式就可以了。利用繼承，就可以讓一個類別具有其他類別的屬性和方法。
首先，既然所有的動物都有年齡，而且都會吃東西、睡覺，那我們就寫個包含這些屬性和方法的Animal類別；這樣子，任何一種動物都可以用Animal類別來描述。當然啦，總有些特性不是每種動物都一樣，就像狗是汪汪叫，而貓是喵喵叫。這時候，我們就可以這樣來描述狗和貓：
- 狗是一種動物。狗具有動物的每一種特性，而且能夠做動物能做的每一件事；除此之外，狗會汪汪叫。
- 貓是一種動物。貓具有動物的每一種特性，而且能夠做動物能做的每一件事；除此之外，貓會喵喵叫。
在繼承時，被繼承的類別叫做「父類別(superclass)」，而繼承別人的，則叫做「子類別(subclass)」；子類別會具有父類別的屬性和方法，同時也可以擁有自己的屬性和方法。所以，既然根據先前的描述，狗和貓都具有動物的每一種特性，那就讓Dog類別和Cat類別分別都繼承Animal類別，這樣子對Animal類別而言，Dog和Cat這兩個類別，就是它的子類別；而對Dog和Cat這兩個類別而言，Animal就是它們的父類別。因此，這麼一繼承下來，Dog和Cat這兩個子類別，就會具有Animal這個父類別的屬性和方法了，不需要重複的寫那麼多的程式碼。根據這樣子的做法，最後Animal、Dog、Cat這三個類別會長這樣：
class Animal:
def __init__(self):
self.age = 0
def eat(self):
print("Yum!")
def sleep(self):
print("Zzzzzz")
class Dog(Animal): # Dog繼承Animal
def bark(self):
print("WOOF!")
class Cat(Animal): # Cat繼承Animal
def meow(self):
print("MEOW!")
執行下面的程式
dog = Dog()
print(dog.age)
dog.eat()
dog.bark()
會得到這樣的結果：
0
Yum!
WOOF!
這樣子的結果，看起來挺不賴的，透過繼承的方式，Dog和Cat這兩個類別的程式碼減少了很多。不過，如果Dog類別中，除了年齡之外，也需要有毛色這個屬性，那該怎麼辦呢？這時候，就要用到super()這個方法了。
繼承時有個規則，就是當子類別的方法和父類別的方法有一樣的名稱時，父類別的方法會被子類別的方法給覆蓋掉，而在子類別中消失。所以，如果為了讓Dog類別也有毛色這個屬性，而把__init__()寫出來，像這樣：
class Dog(Animal):
def __init__(self):
# 用亂數來決定毛色
r = random.randint(0, 255)
g = random.randint(0, 255)
b = random.randint(0, 255)
self.hair_color = (r, g, b)
def bark(self):
print("WOOF!")
那Dog類別的__init__()就會覆蓋掉Animal類別的__init__()，而使得Dog類別沒有繼承到Animal類別__init__()中的任何東西，導致Dog類別不具有age這個屬性。那要怎麼把被覆蓋掉的東西拿回來呢？就用super()這個函數。
super()這個函數的功用，就是用來把父類別的方法拿來繼承。所以，在Dog類別的__init__()中加入一行，改成這樣：
def __init__(self):
super().__init__() # 繼承父類別的__init__()方法
# 用亂數來決定毛色
r = random.randint(0, 255)
g = random.randint(0, 255)
b = random.randint(0, 255)
self.hair_color = (r, g, b)
就可以讓Dog類別在新增hair_color這個屬性時，也同時能夠繼承來自Animal類別__init__()內的age屬性。
在先前的寫法中，狗狗吃東西的方式和其他動物都一樣。那如果狗狗跟其他動物不一樣，有牠自己獨特的吃東西方式時，程式要怎麼寫呢？其實很簡單，就在Dog類別中，把狗狗吃東西的方式寫出來就可以了，像這樣：
class Dog(Animal):
def __init__(self):
super().__init__() # 繼承父類別的__init__()方法
# 用亂數來決定毛色
r = random.randint(0, 255)
g = random.randint(0, 255)
b = random.randint(0, 255)
self.hair_color = (r, g, b)
# 子類別的方法會覆蓋掉父類別的方法
def eat(self):
print("Woof! Woof! Slurp.")
def bark(self):
print("WOOF!")
因為子類別Dog的eat()方法會覆蓋掉父類別Animal的eat()方法，所以狗狗就不會有和其他動物一樣的吃東西方式了。當然啦，如果想要讓狗狗吃東西的時候，既有和其他動物一樣的方式，又有自己獨特的方法，那就用super()把Animal類別的eat()方法繼承過來就可以了，像這樣：
def eat(self):
super().eat() # 繼承Animal類別的eat()方法
print("Woof!!!")
這時候如果執行
dog = Dog()
dog.eat()
就會得到
Yum!
Woof!!!
Polymorphism Basics
利用繼承的方式，我們可以造出一大堆動物的類別。假設我們已經設計好Dog、Cat、Duck、Chicken這些類別，如果現在有滿園子饑腸轆轆的狗、貓、鴨子、雞在吃東西，那程式寫起來會長什麼樣子呢？
第一步，當然是把這些動物給生出來：
dogs = [Dog() for i in range(10)]
cats = [Cat() for i in range(15)]
ducks = [Duck() for i in range(6)]
chickens = [Chicken() for i in range(98)]
然後讓牠們吃東西：
for dog in dogs:
dog.eat()
for cat in cats:
cat.eat()
for duck in ducks:
duck.eat()
for chicken in chickens:
chicken.eat()
程式這樣寫沒什麼問題，有四種動物，我們就用四個迴圈來讓牠們吃東西。不過，如果有幾十種動物呢？那豈不是得寫幾十個迴圈？其實也不用這麼麻煩，利用多型這個技術就可以了。
先前是把四種動物分別放在四個list中，現在把牠們全部集中，放在一個叫做kingdom的list中：
kingdom = []
for i in range(10):
kingdom.append(Dog())
for i in range(15):
kingdom.append(Cat())
for i in range(6):
kingdom.append(Duck())
for i in range(98):
kingdom.append(Chicken())
接下來，用一個迴圈，讓牠們一隻一隻開始吃東西：
for animal in kingdom:
animal.eat()
雖然在kingdom這個list裡頭所放的，是不同種類的物件，但python可以識別出當前處理的是哪一種，並自動幫我們找到其對應的eat()方法。這就是多型的妙用之所在！
Particles with Inheritance and Polymorphism
利用繼承和多型，我們可以很容易就讓原本只噴射圓形粒子的發射器，可以同時噴射出圓形和方形粒子，而且方形粒子還可以邊飛邊旋轉。
因為圓形粒子是由Particle類別所製作出來的，而既然方形粒子和圓形粒子之間的不同點，就只在形狀和邊飛邊旋轉這兩樣而已，所以在設計方形粒子的類別時，可以利用繼承Particle類別的方式，來讓方形粒子具備基本所需的屬性、方法，然後再加入方形粒子獨有的屬性、方法就可以了。
設計好的方形粒子類別如下：
class Confetti(Particle):
def __init__(self, x, y, mass):
super().__init__(x, y, mass)
# 加入方形粒子獨有的屬性，用來計算粒子的旋轉角度
self.width, self.height = self.screen.get_size()
def show(self):
# 使用具透明度的白色把confetti所在的surface清空
self.surface.fill((255, 255, 255, 0))
# 畫出具有透明度的confetti，並根據confetti剩下的壽命長短來決定透明度
rect = pygame.Rect(0, 0, self.size, self.size)
color = (0, 0, 0, self.lifespan)
pygame.draw.rect(self.surface, color, rect)
angle = 4*180*self.position.x/self.width # 旋轉角度
rotated_surface = pygame.transform.rotate(self.surface, -angle)
rect_new = rotated_surface.get_rect(center=self.position)
# 把confetti所在的surface貼到最後要顯示的畫面上
self.screen.blit(rotated_surface, rect_new)
在Confetti類別中，我們重新設計了show()方法，覆蓋掉繼承自Particle類別的show()方法。這樣子，方形粒子就能以自己的形狀和飛行方式，顯現在畫面上。
在計算方形粒子的旋轉角度時，只簡單地使用粒子的x軸座標值來換算。換算公式為：
旋轉角度 = 4π (粒子的x軸座標值) / 畫面寬度
當然啦，也可以用比較複雜一些的方式，像第三章中提到的角速度、角加速度，來設計旋轉角度的計算公式。
Exercise 4.7
讓角加速度的大小等於水平方向的速度大小，也就是
angular_acceleration = velocity.x
然後就可以算出角速度和旋轉的角度。
angular_velocity += angular_acceleration
angle += angular_velocity
有了Particle和Confetti這兩個類別之後，還需要把先前設計的Emitter類別中的add_particle()方法改造一下，才能讓發射器能噴射出方形和圓形兩種粒子。改造後的add_particle()方法程式碼如下：
def add_particle(self):
r = random.random()
if r < 0.5:
self.particles.append(Particle(self.origin.x, self.origin.y, self.mass))
else:
self.particles.append(Confetti(self.origin.x, self.origin.y, self.mass))
在設計Emitter類別時，不管是圓形或方形粒子，我們都把它放在particles這個list中，並在run()這個方法中，藉由多型技術，在不需區分是哪種粒子的情況下，以相同的方式來處理從particles這個list中取出的物件。
下面這個例子模擬的，就是發射器噴射出方形和圓形粒子的情況。
Example 4.5: A Particle System with Inheritance and Polymorphism
# python version 3.10.9
import random
import sys
import pygame # version 2.3.0
pygame.init()
pygame.display.set_caption("Example 4.5: A Particle System with Inheritance and Polymorphism")
WHITE = (255, 255, 255)
screen_size = 640, 360
screen = pygame.display.set_mode(screen_size)
FPS = 60
frame_rate = pygame.time.Clock()
gravity = pygame.Vector2(0, 0.05)
emitter = Emitter(320, 50, 1)
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
screen.fill(WHITE)
emitter.add_particle()
emitter.run()
pygame.display.update()
frame_rate.tick(FPS)
Exercise 4.8
除了橢圓、方形兩種粒子外，多加一種快速旋轉、飛得比較遠的橢圓形粒子。
class Ellipse(Particle):
def __init__(self, x, y, mass):
super().__init__(x, y, mass)
self.width, self.height = self.screen.get_size()
self.velocity = pygame.Vector2(random.uniform(-3, 3), random.uniform(-2, 0))
self.angle = 0
def show(self):
# 使用具透明度的白色把ellipse所在的surface清空
self.surface.fill((255, 255, 255, 0))
# 畫出具有透明度的ellipse，並根據ellipse剩下的壽命長短來決定透明度
rect = pygame.Rect(0, 0, self.size, self.size/2)
color = (0, 0, 0, self.lifespan)
pygame.draw.ellipse(self.surface, color, rect)
self.angle += 10*self.velocity.x # 旋轉角度
rotated_surface = pygame.transform.rotate(self.surface, -self.angle)
rect_new = rotated_surface.get_rect(center=self.position)
# 把ellipse所在的surface貼到最後要顯示的畫面上
self.screen.blit(rotated_surface, rect_new)
修改Emitter類別的add_particle()方法，讓三種粒子出現的機率一樣。
def add_particle(self):
match random.randint(1, 3):
case 1:
self.particles.append(Particle(self.origin.x, self.origin.y, self.mass))
case 2:
self.particles.append(Confetti(self.origin.x, self.origin.y, self.mass))
case 3:
self.particles.append(Ellipse(self.origin.x, self.origin.y, self.mass))
執行結果
你可能也想看
