Overload (多載) vs. Override (覆寫) - (I)

Overload (多載) 與 Override (覆寫) 為程式設計的 2 個常見性質，
對物件導向程式設計 (OOP) 尤其重要。

或許是原文相似的關係，兩者時常令初學者搞混 😨，
不然就是對其了解只停留在：
「多個相同方法名稱」、「改寫父類別方法」…，而不懂實際運用。

別擔心！本篇將以簡單的例子，闡明各自用途、使用方式，
使您不再模凌兩可，並運用自如 😆。

[註]:
若無指明，本篇使用的語言預設為 Java。

Overload (多載)

Overload (多載)

在解釋 Overload (多載) 的含義之前，先來記憶名詞吧！

「 Load 」本身有乘載、負擔、負荷、負載的意思。

於是，加上一個 Down，成了 Download (下載)，
若加上一個 Over，則成了 — Overload (多載) 啦！
又譯為：超載、覆載、重載、過載…「各種」載。

恭喜，您已學會分辨 Overload (多載) 與 Override (覆寫) 😂。

其實你學過了！

Overload (多載) 的觀念其實您已見過無數次 😂！
其為 Christopher Strachey 於 1967 年提出的一特定多型 (Ad hoc polymorphism) 機制，
簡單來說就是：根據不同情境『相同的模樣，擁有不同的行為』。

還記得國小數學嗎？
當時的「+」、「–」運算子，純粹就是做正數的加法、減法。

然而上了國一，老師告訴你負數的觀念：「–3 + 5 = 2」，
以及如何強調一個正數：「+10」…。

這時你發現了：

一樣都長「+」、「–」，在不同時候卻有不同意義 (加減 vs. 正負數)。

會了 😇：
這正是運算子多載 (Operator Overloading)！
— — 將多載觀念：『相同的模樣，擁有不同的行為』，應用在運算子上。

沒錯，Java 串接字串使用的「+」，一樣是運算子多載喔！
另外，可別忘記字串是 immutable (永不改變的) ！

public class Main {

    public static void main(String[] args) {

        String name = "Jason";
        String output = "Hello, " + name + "!";

        System.out.println(output);
    }
}

/*
 * Output:
 * 
 * Hello, Jason!
 */

[註]:
不同於某些語言 (e.g., C++)，
Java、C… 並不提供『自訂的運算子多載』，詳見此篇。

需注意的是，當有人同時提及 Overload (多載) 與 Override (覆寫) 時，
87% 指的都是方法多載 (Method Overloading)，而非運算子多載唷 😲！

方法多載 (Method Overloading)

方法多載 (Method Overloading) or 函式/建構子多載，顧名思義：
將觀念『相同的模樣，擁有不同的行為』，應用在方法/函式/建構元上。

運算子的模樣很簡單：「 + – * / & ^ | << >>… 」，
而『方法的模樣』便是指 — 方法名稱 (method’s name) ，
也就是：相同的方法名稱，擁有不同的實作。

條件是：

參數串列 (parameter list) 得不同
( 包含不同的參數型別、數量 )

例如：

void test();
void test(int i);
void test(char c);
void test(String s, int i);
void test(String s, String s2);

[註]:
大多數物件導向程式語言皆支援方法多載 (e.g., Java, C++)，
而傳統的結構化程式語言 (e.g., C 語言) 不支援。

無多載方法

直接看個栗子 🌰

Bob 是個愛煎牛排的固執廚師 (chef)：

你可以跟他點餐，但你沒有選擇 (無參數)，永遠只有牛排 😂：

public class Main {

    public static void main(String[] args) {

        Chef bob = new Chef();

        bob.cook(); // 牛排x1
    }
}

// 廚師 (chef)
class Chef {

    // 回傳型別： void
    // 參數型別： 無
    void cook() {
        System.out.println("準備餐點: 牛排");
    }
}

多載方法 (增加參數)

儘管 Bob 只想煎牛排，最後還是向現實屈服了：
允許顧客點餐 (增加 char 參數)，
目前只提供 A號餐、B號餐，若您北爛亂點餐 Bob 會很生氣：

public class Main {

    public static void main(String[] args) {

        Chef bob = new Chef();

        bob.cook(); // 牛排x1

        bob.cook('B'); // 豬排x1

        bob.cook('C'); // 食屎
    }
}

class Chef {

    // 回傳型別： void
    // 參數型別： 無
    void cook() {
        System.out.println("準備餐點: 牛排");
    }

    // 回傳型態： void
    // 參數型態： char
    void cook(char meal) {
        switch (meal) {
            case 'A':
                System.out.println("準備 A 號餐: 牛排");
                break;
            case 'B':
                System.out.println("準備 B 號餐: 豬排");
                break;
            default:
                System.out.println("食屎吧你");
                break;
        }
    }
}

舉凡遊戲 id、樂團名稱…，取名字都是一件麻煩事 😒，
方法多載 (Overload) 讓我們得以使用相同名稱宣告方法 😇，
而非取個 cookforOrder(char c) 或 cook2(char c)…。

感恩多載，讚嘆多載

多載方法 (多個參數)

身為一個專業的廚師，讓顧客指定數量也是很合理的 (增加 int 參數)：

// 回傳型別： void
// 參數型別： char, int
void cook(char meal, int quantity) {
    if (quantity < 1)
        return;
    switch (meal) {
        case 'A':
            System.out.println("準備 A 號餐: 牛排");
            break;
        case 'B':
            System.out.println("準備 B 號餐: 豬排");
            break;
        default:
            System.out.println("食屎吧你");
            break;
    }
    // 做好一份了，剩下 quantity - 1 份
    cook(meal, quantity - 1); // 遞迴呼叫
}

[註]:
最後一行，使用自己呼叫自己的技巧，稱為遞迴 (Recursion)。

執行結果：

public class Main {

    public static void main(String[] args) {

        Chef bob = new Chef();
    
        bob.cook('A'); // 牛排x1

        bob.cook('B', 3); // 豬排x3
    }
}

有沒有好方便！儘管呼叫相同的方法名稱，
程式會自動找到對映的參數型別 (或無參數) 以執行。

關鍵在於：

呼叫的參數型別、順序或數量不同
cook( ) vs. cook(“A”) vs. cook(‘B’, 3);

方法簽章 (Method Signature)

整理一下，目前廚師 (Chef) 類別的多載方法：

class Chef {

    // 回傳型別： void
    // 參數型別： 無
    void cook() {
        ... 略 ...
    }

    // 回傳型別： void
    // 參數型別： char
    void cook(char meal) {
        ... 略 ...
    }

    // 回傳型別： void
    // 參數型別： char, int
    void cook(char meal, int quantity) {
        ... 略 ...
    }
}

Q1: 請問，是否能再擴充以下方法？ (參數串列與 cook(char meal) 衝突，但修改回傳型態 )

boolean cook(char meal){
    ... 略 ...
}

Ans:

不行！
因為其參數串列與 void cook(char meal) 的重複了！

在 Java 中：
方法簽章 (Method Signature) = 方法名稱 (method’s name) + 參數型別 (parameter types)，
用以決定方法的唯一性，其中 Signature 又譯為：外貌簽名、簽署、署名。

編譯器是使用方法簽章 (Method Signature) 區分不同方法，而非回傳型別 (return type)，
因此，不能宣告兩個具有相同簽章的方法。

[註]:
相同的觀念也出現在 C# 中：
方法的傳回類型不是方法多載用途的方法簽章的一部分。
不過，在判斷委派與所指向的方法之間的相容性時，它是方法簽章的一部分。

然而，這也衍伸了一個問題：
Q2：請問，是否能再擴充以下方法？ (參數串列與 Chef 類別無衝突，但修改回傳型態 )

boolean cook(int i){
    ... 略 ...
}

Ans:

可以，但最好不要！

從範例中可得知，重載方法之間雖然參數串列不同，
但功能是一致的 — 烹飪 (cook)。

重載方法之間，若回傳型別不同，
將使程式碼難以維護、理解，若有新的意圖應取新的方法名稱。
— — 軟體開發大師 Kent Beck.

重構 — 重複的程式碼 (Duplicated Code)

程式碼的壞味道 (Bad Smells in Code, by Kent Beck & Martin Fowler) 中，
首當其衝的便是重複的程式碼 (Duplicated Code) !

讓我們看看，截至目前為止 Chef 類別，有多少『準備餐點』😱：

class Chef {

    void cook() {
        System.out.println("準備 A 號餐: 牛排");
    }

    void cook(char meal) {
        switch (meal) {
            case 'A':
                System.out.println("準備 A 號餐: 牛排");
                break;
            case 'B':
                System.out.println("準備 B 號餐: 豬排");
                break;
            default:
                System.out.println("食屎吧你");
                break;
        }
    }

    void cook(char meal, int quantity) {

        if (quantity < 1)
            return;

        switch (meal) {
            case 'A':
                System.out.println("準備 A 號餐: 牛排");
                break;
            case 'B':
                System.out.println("準備 B 號餐: 豬排");
                break;
            default:
                System.out.println("食屎吧你");
                break;
        }

        // 做好一份了，剩下 (quantity - 1) 份
        cook(meal, quantity - 1); // 遞迴呼叫
    }
}

真的是臭到爆了 😂，而且第二個函式還 100% 出現在第三個函式中…。

別擔心，由於多載函式大多目的一致，
大多內建『重複的程式碼』之解法 — 提煉函式。

void cook() 方法，能夠點一份牛排，
而 void cook(char meal) 方法，能點一份牛排或豬排，
於是我們能夠如此重構：

void cook() {
    cook('A'); // 呼叫多載函式
}

void cook(char meal) {
    switch (meal) {
        case 'A':
            System.out.println("準備 A 號餐: 牛排");
            break;
        case 'B':
            System.out.println("準備 B 號餐: 豬排");
            break;
        default:
            System.out.println("食屎吧你");
            break;
    }
}

又 void cook(char meal) 只能點一份牛排或豬排，
但 void cook(char meal, int quantity) 能夠點很多份牛排或豬排！
於是我們能夠如此重構：

void cook(char meal) {
    cook(meal, 1); // 相當於數量 x1
}

最後：

class Chef {

    // 點一份 牛排
    void cook() {
        cook('A');
    }

    // 點一份 牛排 or 豬排
    void cook(char meal) {
        cook(meal, 1);
    }

    // 點很多份 牛排 or 豬排
    void cook(char meal, int quantity) {

        if (quantity < 1)
            return;

        switch (meal) {
            case 'A':
                System.out.println("準備 A 號餐: 牛排");
                break;
            case 'B':
                System.out.println("準備 B 號餐: 豬排");
                break;
            default:
                System.out.println("食屎吧你");
                break;
        }

        // 做好一份了，剩下 quantity - 1 份
        cook(meal, quantity - 1); // 遞迴呼叫
    }
}

是否乾淨許多呢 😆！

But，得注意的是：

對未包含共同程式或邏輯的方法，可能並不適用，
例如，需依不同型別做個別的處理的方法 (method)。

建構子多載 (Constructor Overloading)

建構子 (Constructor) 是一種特殊的方法，會在類別被實例 (new) 時自動執行，
建構子沒有回傳值，且名稱必須與類別相同。

上方的重構技巧，便常見於『具有多個建構子 (Constructor) 的類別』中，
常見的做法是：『由簡單去呼叫複雜』。

例如，我們要製作一個具有長、寬、顏色的長方形 (Rectangle)，
且若無指定值，預設是寬500 高309 藍色的長方形，一開始可能寫成：

class Rectangle {

    int width;
    int height;
    int color;

    Rectangle() {
        this.width = 500;
        // 別問我為何 1.618...去問歐幾里得
        this.height = (int) (width / 1.618); 
        this.color = 0x2196F3; // 藍色
    }

    Rectangle(int width) {
        this.width = width;
        this.height = (int) (width / 1.618);
        this.color = 0x2196F3; // 藍色
    }

    Rectangle(int width, int height) {
        this.width = width;
        this.height = height;
        this.color = 0x2196F3; // 藍色
    }

    Rectangle(int width, int height, int color) {
        this.width = width;
        this.height = height;
        this.color = color;
    }
}

沒關係 😆，照著廚師 (chef) 類別依樣畫葫蘆，進行重構 ❗️

class Rectangle {

    int width;
    int height;
    int color;

    Rectangle() {
        this(500); // 正確 (O)
//        Rectangle(width); 錯誤 (X) -- 得使用 this 關鍵字
    }

    Rectangle(int width) {
        this(width, (int) (width / 1.618));
    }

    Rectangle(int width, int height) {
//        int area = width * height; 錯誤 (X) -- 利用「this」呼叫建構子，需為首句敘述
        this(width, height, 0x2196F3);
    }

    // 主建構函式
    Rectangle(int width, int height, int color) {
        this.width = width;
        this.height = height;
        this.color = color;
    }
}

跟上節的重構非常相似！但最大的不同在於：

建構子無法像方法一樣以名稱呼叫，得透過關鍵字 this 或 super (子類別)，
且該 this 或 super 必須是該建構元的首句敘述 (first statement)。

注意：
this() 和 this. 不一樣喔！
this() 用於在建構元中呼叫其他建構元，且需為首句敘述 (first statement)，
this. 用於存取類別中的欄位 (例 this.width)，放第一萬行也沒關係！

最後，我們便能以簡單的方式建立長方形，也可以詳細的對其進行設定 😆：

無參數建構子：

三參數建構子：

附上 Main 程式碼：

import javax.swing.*;
import java.awt.*;

public class Main {

    public static void main(String[] args) {
        Rectangle defaultRec = new Rectangle();
        showJFrame(defaultRec);
    }

    static JFrame showJFrame(Rectangle r) {

        int width = r.width;
        int height = r.height;
        Color color = new Color(r.color);

        // 簡易的 Swing 圖形化介面
        JFrame frame = new JFrame();
        frame.setSize(width, height);
        frame.setLocationRelativeTo(null);
        frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        frame.getContentPane().setBackground(color);
        frame.setVisible(true);
        return frame;
    }
}

以上的作法，便是軟體開發大師 Kent Beck 提及：

將所有建構函式，轉接道一個『主建構函式』，
以向未來的維護/修改者，傳達這些『不會改變的要求』。

子類別的多載

最後，得注意的是：
『多載不只會發身在自身類別，繼承/實作的子類別同樣能多載父類別的方法！』

public class Main {

    public static void main(String[] args) {
        new A().test(); // A

        new B().test(); // B

        new B().test('C'); // C
    }
}

class A {
    void test() {
        System.out.println('A');
    }
}

class B extends A {

    // 覆寫 (Override)
    void test() {
        System.out.println('B');
    }

    // 多載 (Overload)
    void test(char c) {
        System.out.println(c);
    }
}

然而，可別忘了多載的條件是：

參數串列 (parameter list) 得不同
( 包含不同的參數型別、數量 )

若方法簽章 (方法名稱+參數串列) 與父類別相同，
並非多載，而是 Override (覆寫) — 會將父類別的方法覆蓋掉 (改寫)，
詳細觀念將於下篇提及 😄。

總結

多載 (Overlaod) 大幅地增加了程式開發的便利性，
例如，Java 的 valueOf 函式，提供了多種多載方法，
使我們得以用相同的方法名稱，執行不同資料型別的轉型操作：

然而，Overload (多載) 與 Override (覆寫) 其實是息息相關的，
皆是實踐多型 (polymorphism) 的技術之一，
善用這些技巧，才能有效實作彈性、可擴充的程式，
Override (覆寫) 的觀念將在下篇提及 😁。

在《Overload (多載) vs. Override (覆寫) — (I)》中有 13 則留言

Sandra表示:
2017-09-1418:06:11
獲益良多，非常感謝，是個非常優秀的老師😁
回覆
吳建儒四資工三甲表示:
2017-10-0909:57:19
受益匪淺，感謝分享。
回覆
匿名訪客表示:
2017-12-0811:57:43
感謝大神
回覆
匿名訪客表示:
2018-01-3010:12:57
這個很有用,感謝～～～～
回覆
匿名訪客表示:
2018-02-2317:34:14
真的很實用!感謝您
回覆
匿名訪客表示:
2018-03-0723:51:16
解釋的詳細又清楚，謝謝你～
回覆
1. 鄭中勝表示:
  2018-05-2001:34:09
  謝謝你們 😃
  回覆
zimo wang表示:
2018-10-1909:39:42
感谢分享，例子非常简单易懂
回覆
1. 鄭中勝表示:
  2018-10-2217:14:32
  謝謝 😄
  回覆
  1. 匿名訪客表示:
    2018-12-1311:30:51
    謝謝！講的很詳細 :
    回覆
    1. 鄭中勝表示:
      2018-12-2120:29:17
      非常感謝！😆
      回覆
匿名訪客表示:
2019-09-1711:33:57
例子淺顯易懂講解得非常棒謝謝您的說明!
回覆
匿名訪客表示:
2023-07-2517:07:58
寫得還不錯咧臭小子～
回覆

NotFalse 技術客

Overload (多載) vs. Override (覆寫) — (I)

Overload (多載)

其實你學過了！

方法多載 (Method Overloading)

無多載方法

多載方法 (增加參數)

多載方法 (多個參數)

方法簽章 (Method Signature)

重構 — 重複的程式碼 (Duplicated Code)

建構子多載 (Constructor Overloading)

子類別的多載

總結

More

在《Overload (多載) vs. Override (覆寫) — (I)》中有 13 則留言

發表迴響取消回覆

Overload (多載)

其實你學過了！

方法多載 (Method Overloading)

無多載方法

多載方法 (增加參數)

多載方法 (多個參數)

方法簽章 (Method Signature)

重構 — 重複的程式碼 (Duplicated Code)

建構子多載 (Constructor Overloading)

子類別的多載

總結

分享此文：

More

在《Overload (多載) vs. Override (覆寫) — (I)》中有 13 則留言

發表迴響 取消回覆

發表迴響取消回覆