你大概有過這種經驗。手上要加一個小功能,程式碼早就寫在腦子裡了,結果卡在一個問題上:這個方法該放哪個 class?

放 Order 好像不對,它管的不只是訂單。放 User 也怪,跟使用者沒什麼關係。開一個 OrderHelper?那 OrderManager 和 OrderService 又是什麼。

想了二十分鐘,最後隨便挑一個塞進去,心裡知道下次還會再想一次。

這個卡點來自學校教物件導向的方式。

學校教的第一個坑:企鵝不會飛

課本一開始都是這樣教的:鳥會飛,所以寫一個 Bird 類別,裡面放 fly()。麻雀是鳥,老鷹是鳥,都繼承 Bird,直接就有 fly() 可以用。很漂亮。

class Bird {  
    void fly() { System.out.println("飛走了"); }  
}  
  
class Sparrow extends Bird { }   // 麻雀,沒問題  
class Penguin extends Bird { }   // 企鵝……

企鵝是鳥。企鵝不會飛。

你可以在 Penguin 裡把 fly() 覆寫成丟例外,但這等於承認一件事:任何拿到 Bird 的程式碼,都不能安心呼叫 fly()。那 Bird 這個抽象就沒用了。

第二個坑更狠:正方形不是長方形

數學上,正方形是長方形的一種。照課本的邏輯,Square extends Rectangle 理所當然。

class Rectangle {  
    protected int width, height;  
    void setWidth(int w)  { width = w; }  
    void setHeight(int h) { height = h; }  
    int area() { return width * height; }  
}  
  
class Square extends Rectangle {  
    void setWidth(int w)  { width = w; height = w; }  // 正方形長寬要一樣  
    void setHeight(int h) { width = h; height = h; }  
}

看起來沒毛病。現在有另一個人寫了這個函式:

void resize(Rectangle r) {  
    r.setWidth(5);  
    r.setHeight(4);  
    System.out.println(r.area());   // 他預期 20  
}

傳 Rectangle 進去印 20。傳 Square 進去印 16。

寫 resize 的人沒有做錯任何事,他只是相信「Square 是一種 Rectangle」。這個 bug 藏在繼承關係本身,測試不容易抓到,因為兩個類別各自看都是對的。

這個現象有名字,叫 Liskov 替換原則被違反。你不用記名字,記住結論就好:「A 是一種 B」這句話在日常語言裡成立,不代表在程式裡可以用繼承表達。

業界已經用腳投票了

這些坑不是新聞,吵了三十年。真正有意思的是語言設計者的反應。

過去十幾年最重要的兩個系統程式語言,Google 的 Go(2012 年發布 1.0)和 Mozilla 出身的 Rust(2015 年發布 1.0),都沒有繼承。Go 的官方問答集裡有一條標題直接叫「Why is there no type inheritance?」,等於官方出面解釋為什麼要跳過它。

兩個從零開始設計、不用背任何歷史包袱的語言,都決定跳過繼承。這比任何論戰都有說服力。

那物件導向剩下什麼

「物件導向」這個詞其實打包了四樣不同的東西。被丟掉的只有繼承,另外三樣活得好好的。

第一,封裝。 把資料藏起來,只留幾個對外的入口。這個原則完全沒事,只是範圍變大了:以前是「一個 class 藏自己的欄位」,現在是「一個模組藏自己的實作細節」。你的 OrderService 對外只開三個方法,內部十五個輔助函式外面看不到,這就是封裝,跟有沒有繼承無關。

第二,介面。 這個最像插座。你家牆上的兩孔插座不管接電風扇還是檯燈,只要插頭規格對就能用。插座不需要知道對方是什麼電器,只需要知道「你有兩根腳」。

Java 的 interface 就是這個。它只問一句「你能做什麼」。回頭看企鵝那個例子,用介面就不會出事:

interface CanFly { void fly(); }  
  
class Sparrow implements CanFly { public void fly() { ... } }  
class Penguin { }   // 企鵝不實作 CanFly,問題自動消失

第三,傳訊息。 這個聽起來抽象,其實你每天在用。你的服務不能直接去讀別人資料庫裡的欄位,只能發一個 HTTP 請求過去問。這就是傳訊息:各自管好自己的狀態,溝通只能敲門,不能翻對方抽屜。微服務架構本質上就是這件事。

有趣的是,Smalltalk 的作者 Alan Kay(1972 年做出這個語言,比 C++ 早十年以上)在 1998 年說過:「我很後悔當年造了 objects 這個詞,它讓很多人把注意力放在比較次要的想法上。真正的大想法是 messaging。」

發明這個詞的人,重點從來就不在類別上。

「資料跟行為分開」白話是什麼

現在講最實用的一件事。

傳統寫法是把資料和操作綁在同一個 class 裡:

class Order {  
    private List<Item> items;  
    private String status = "新建";  
  
    public void applyDiscount(int percent) {  
        for (Item i : items) {  
            i.price = i.price * (100 - percent) / 100;  
        }  
        this.status = "已折扣";  
    }  
}

applyDiscount 回傳 void,它偷偷改了 items 和 status。從外面看,你只知道呼叫完之後這個物件「變了」,變成什麼要自己去問。

拆開來寫是這樣:

# 資料就是一包資料,沒有方法  
Order = namedtuple("Order", "items status")  
  
# 行為是一個函式:吃一張舊訂單,吐一張新訂單  
def apply_discount(order, percent):  
    new_items = [  
        i._replace(price=i.price * (100 - percent) // 100)  
        for i in order.items  
    ]  
    return Order(items=new_items, status="已折扣")

差在哪?三件事,都很實際。

原本那張單子還在。 折扣算錯的時候,你手上同時有折扣前和折扣後兩份資料,印出來對一下就知道哪裡歪了。Java 那個版本原始資料已經被蓋掉,想比對得自己先複製一份。

加功能不用動舊程式碼。 要加「計算運費」就再寫一個 calc_shipping(order),Order 完全不用碰。這正是繼承最痛的地方:改一個基底類別,整棵樹底下的類別都要重跑測試。

測試好寫太多。 測 apply_discount 就是餵一份資料進去,檢查吐出來的對不對,三行搞定。測 Java 那個版本,你得先 new 一個 Order、塞好 items、設好 status、呼叫方法、再想辦法把私有欄位挖出來檢查。

設計模式那本書可以先放著

《Design Patterns》1994 年出版,四個作者,二十三個模式,1990 年代的程式設計師人手一本。

今天大部分可以跳過。不是模式寫錯了,是語言把洞補起來了。

當年 Java 和 C++ 缺一樣東西,叫「第一級函式」。白話講就是:函式不能像數字、字串那樣存進變數、當參數傳來傳去。Python 一直都能,C++ 到 2011 年、Java 到 2014 年才補上。

這個洞造成什麼結果?舉 Strategy 模式當例子。它要解決的問題很單純:「我想把一段行為當參數傳進去」。1994 年的 Java 做不到,只好繞一大圈:先定義一個介面,再寫三個實作類別,再寫一個持有策略物件的 context 類別,大概四十行。

Python 的寫法:

def sort_by(items, key_fn):  
    return sorted(items, key=key_fn)  
  
sort_by(orders, lambda o: o.total)      # 照金額排  
sort_by(orders, lambda o: o.created_at)  # 照時間排

三行。key_fn 就是傳進來的策略。

同一類的還有好幾個。Command 模式現在就是一個 closure(記住了外面變數的函式);Factory Method 就是一個回傳物件的函式;Iterator 早就內建在 Python 的 for x in y 裡;Observer 變成框架給你的 callback。

Peter Norvig 在 1996 年就講過這件事,他算過二十三個模式裡有十六個,在動態語言裡「不可見或更簡單」。

真正留下價值的是那幾個處理結構問題的:State(把狀態機寫清楚)、Adapter(接兩個不相容的介面)、Facade(把一坨複雜度收在一個入口後面)。這三個不用背,寫久了自然會長出來。

那該學什麼

把背設計模式的時間挪去這五項,划算得多。

資料怎麼流。 一個請求進來,資料變成什麼形狀、經過哪幾層、最後吐出去長怎樣。你 debug 的時候追的就是這條線,不是類別關係圖。

誰負責釋放。 C++ 寫過就知道這有多痛,野指標、重複 delete 都是這個問題。Java 有 GC 幫你收,但「忘記移除 listener」照樣會漏。這件事每個語言都存在,Rust 只是逼你在編譯期就講清楚。

狀態機。 訂單有哪些狀態、哪些轉換合法。很多 bug 的本質是程式允許了不該存在的狀態,例如「已取消」但還在扣款。拿張紙畫出來,比任何設計模式都有用。

介面設計。 Go 標準庫有個 io.Reader,只規定一個方法 Read,就讓檔案、網路連線、壓縮檔、記憶體緩衝區可以互相替換。想想為什麼一個方法就夠,比背十個模式有收穫。

並行。 Java 的 thread 和 synchronized、Python 的 asyncio、Go 的 goroutine,各自在解什麼問題、代價是什麼。1994 年那本書完全沒碰這塊,而現在幾乎每支程式都要面對。

什麼時候丟拐杖

用物件入門是對的。人腦本來就擅長把世界想成「有屬性、會做事的個體」,新人第一次寫 user.save() 比第一次寫 save(user) 好懂太多。這根拐杖該用。

問題是很多人拄了十年還沒丟。系統長成七層繼承樹,改一行基底類別要重跑全部測試,每個類別裡一半是狀態一半是行為,沒有人說得清某個欄位是在哪一步被誰改掉的。

回到開頭那個卡點。當你為了「這個功能該放哪個 class」想超過十分鐘,那通常代表答案是:它不屬於任何 class。

它只是一個轉換,吃一份資料、吐一份資料。寫成一個函式就好。

vocus|新世代的創作平台