GoF 設計模式與重構

確保一個類別只有一個實體，並提供全域存取點。透過私有建構子和靜態方法來控制實體化。

public class DatabasePool {
    // volatile 確保多執行緒下的記憶體可見性
    private static volatile DatabasePool instance;

    private DatabasePool() {} // 私有建構子

    // 雙重檢查鎖定 (DCL) — 執行緒安全
    public static DatabasePool getInstance() {
        if (instance == null) {
            synchronized (DatabasePool.class) {
                if (instance == null) {
                    instance = new DatabasePool();
                }
            }
        }
        return instance;
    }
}

// Spring 推薦做法：@Component 預設就是 Singleton
// 框架保證 Bean 唯一，不用自己實作

定義一個創建物件的介面，由子類決定實例化哪一個類別。讓子類決定要創建哪種物件，將創建邏輯延遲到子類。

// 1. 產品介面
interface Notification {
    void send(String msg);
}

// 2. 具體產品
class EmailNotification implements Notification {
    public void send(String msg) {
        System.out.println("Email: " + msg);
    }
}
class SmsNotification implements Notification {
    public void send(String msg) {
        System.out.println("SMS: " + msg);
    }
}

// 3. 工廠介面（子類決定要創建哪個）
abstract class NotificationFactory {
    public abstract Notification createNotification();

    // 範本方法：利用工廠創建的物件執行業務
    public void notify(String msg) {
        createNotification().send(msg);
    }
}

// 4. 具體工廠
class EmailFactory extends NotificationFactory {
    public Notification createNotification() {
        return new EmailNotification();
    }
}

// 使用
NotificationFactory factory = new EmailFactory();
factory.notify("訂單已成立"); // 不需知道是 Email 還是 SMS

提供一個介面，用於創建一系列相關或相依物件的家族，而不需指定具體類別。確保同一家族的產品能配套使用。

// 抽象產品族
interface Button    { void render(); }
interface TextField { void render(); }

// Windows 產品族
class WinButton    implements Button    {
    public void render() { System.out.println("Windows Button"); }
}
class WinTextField implements TextField {
    public void render() { System.out.println("Windows TextField"); }
}

// Mac 產品族
class MacButton    implements Button    {
    public void render() { System.out.println("Mac Button"); }
}
class MacTextField implements TextField {
    public void render() { System.out.println("Mac TextField"); }
}

// 抽象工廠介面
interface GUIFactory {
    Button createButton();
    TextField createTextField();
}

// 具體工廠（只需替換工廠，整套 UI 風格就切換了）
class WindowsFactory implements GUIFactory {
    public Button createButton()       { return new WinButton(); }
    public TextField createTextField() { return new WinTextField(); }
}

class MacFactory implements GUIFactory {
    public Button createButton()       { return new MacButton(); }
    public TextField createTextField() { return new MacTextField(); }
}

將一個複雜物件的構建過程與它的表示分離，使得同樣的構建過程可以創建不同的表示。解決「建構子參數過多」的問題。

public class User {
    private final String name;   // 必填
    private final String email;  // 必填
    private final String phone;  // 選填
    private final int    age;    // 選填

    private User(Builder b) {
        this.name  = b.name;
        this.email = b.email;
        this.phone = b.phone;
        this.age   = b.age;
    }

    public static class Builder {
        private String name, email, phone;
        private int age;

        public Builder(String name, String email) {
            this.name = name; this.email = email;
        }
        public Builder phone(String p) { this.phone = p; return this; }
        public Builder age(int a)      { this.age = a;   return this; }
        public User build()            { return new User(this); }
    }
}

// 使用：鏈式呼叫，意圖清晰
User user = new User.Builder("Andy", "andy@example.com")
    .phone("0912-345-678")
    .age(30)
    .build();

// Lombok 讓你只需一個 @Builder 注解即可自動生成以上所有程式碼

用原型實體指定創建物件的種類，並透過拷貝這些原型來創建新物件。當物件初始化成本昂貴時，複製比重新建立更有效率。

public class Config implements Cloneable {
    private String host;
    private int    port;
    private Map<String, String> settings; // 注意！這是引用型別

    @Override
    protected Config clone() throws CloneNotSupportedException {
        Config copy = (Config) super.clone(); // 淺拷貝：基本型別正確
        // 引用型別必須手動深拷貝，否則兩物件共用同一個 Map！
        copy.settings = new HashMap<>(this.settings);
        return copy;
    }
}

// 使用：當 loadExpensiveConfig() 需要 2 秒時，複製幾乎是瞬間的
Config template = loadExpensiveConfig(); // 只做一次，慢是可以接受的
Config config1  = template.clone();      // 瞬間複製
Config config2  = template.clone();

config1.setHost("server-1");  // 修改不影響 template 和 config2
config2.setHost("server-2");

將類別的介面轉換成客戶端期待的另一種介面。讓原本因介面不相容而無法合作的類別可以合作，相當於電源插座的轉接頭。

// 舊系統介面（無法修改）
class LegacyLogger {
    public void legacyLog(String level, String msg) {
        System.out.println("[" + level + "] " + msg);
    }
}

// 新系統期待的介面
interface Logger {
    void info(String msg);
    void error(String msg);
}

// 轉接器：讓舊 Logger 符合新介面
class LoggerAdapter implements Logger {
    private final LegacyLogger legacy;

    public LoggerAdapter(LegacyLogger legacy) {
        this.legacy = legacy;
    }

    @Override
    public void info(String msg) {
        legacy.legacyLog("INFO", msg); // 轉換呼叫方式
    }

    @Override
    public void error(String msg) {
        legacy.legacyLog("ERROR", msg);
    }
}

// 客戶端只知道 Logger 介面，不知道底層是 LegacyLogger
Logger log = new LoggerAdapter(new LegacyLogger());
log.info("Server started");

將抽象部分與實現部分分離，使它們都可以獨立地變化。避免因「抽象 × 實作」兩個維度導致的繼承爆炸問題。

// 實作層（如何傳送）
interface MessageSender {
    void sendMessage(String msg);
}
class EmailSender implements MessageSender {
    public void sendMessage(String msg) { System.out.println("Email: " + msg); }
}
class SmsSender implements MessageSender {
    public void sendMessage(String msg) { System.out.println("SMS: " + msg); }
}

// 抽象層（發送什麼）—— 持有實作的引用（橋）
abstract class Message {
    protected MessageSender sender; // 橋接點！
    public Message(MessageSender sender) { this.sender = sender; }
    public abstract void send(String content);
}

class UrgentMessage extends Message {
    public UrgentMessage(MessageSender s) { super(s); }
    public void send(String content) {
        sender.sendMessage("[緊急] " + content);
    }
}

class NormalMessage extends Message {
    public NormalMessage(MessageSender s) { super(s); }
    public void send(String content) { sender.sendMessage(content); }
}

// 自由組合：緊急 × SMS、普通 × Email...等等，無需新增子類
new UrgentMessage(new SmsSender()).send("系統異常");
new NormalMessage(new EmailSender()).send("每日報告");

將物件組合成樹狀結構以表示「部分-整體」的層次結構。讓客戶端對單個物件和組合物件的使用具有一致性。

// 統一介面：葉節點與容器都實作它
interface FileSystemItem {
    void display(String indent);
    long getSize();
}

// 葉節點（Leaf）—— 沒有子節點
class File implements FileSystemItem {
    private String name;
    private long size;

    public File(String name, long size) {
        this.name = name; this.size = size;
    }
    public void display(String indent) {
        System.out.println(indent + "📄 " + name + " (" + size + "B)");
    }
    public long getSize() { return size; }
}

// 容器（Composite）—— 可包含葉節點或其他容器
class Folder implements FileSystemItem {
    private String name;
    private List<FileSystemItem> children = new ArrayList<>();

    public Folder(String name) { this.name = name; }
    public void add(FileSystemItem item) { children.add(item); }

    public void display(String indent) {
        System.out.println(indent + "📁 " + name);
        children.forEach(c -> c.display(indent + "  ")); // 遞迴
    }
    public long getSize() {
        return children.stream().mapToLong(FileSystemItem::getSize).sum();
    }
}

// 客戶端：完全不需要區分是 File 還是 Folder
Folder root = new Folder("root");
root.add(new File("config.yaml", 1024));
Folder src = new Folder("src");
src.add(new File("Main.java", 4096));
root.add(src);
root.display("");

動態地給物件增加一些額外的職責。就功能而言，裝飾器比繼承更為靈活，可以在執行時動態組合功能。

// 原始介面
interface Coffee {
    String getDescription();
    double getCost();
}

// 原始實作
class SimpleCoffee implements Coffee {
    public String getDescription() { return "咖啡"; }
    public double getCost()        { return 30.0; }
}

// 裝飾器基礎類別（持有被裝飾的物件）
abstract class CoffeeDecorator implements Coffee {
    protected Coffee coffee;
    public CoffeeDecorator(Coffee c) { this.coffee = c; }
}

// 具體裝飾器
class MilkDecorator extends CoffeeDecorator {
    public MilkDecorator(Coffee c) { super(c); }
    public String getDescription() { return coffee.getDescription() + " + 牛奶"; }
    public double getCost()        { return coffee.getCost() + 10.0; }
}

class SugarDecorator extends CoffeeDecorator {
    public SugarDecorator(Coffee c) { super(c); }
    public String getDescription() { return coffee.getDescription() + " + 糖"; }
    public double getCost()        { return coffee.getCost() + 5.0; }
}

// 動態堆疊裝飾器，像洋蔥一樣層層包裹
Coffee c = new SimpleCoffee();
c = new MilkDecorator(c);   // 加牛奶
c = new SugarDecorator(c);  // 再加糖
System.out.println(c.getDescription() + " $" + c.getCost());
// 輸出：咖啡 + 牛奶 + 糖 $45.0

為子系統中的一組介面提供一個統一的高層介面，使複雜的子系統更加容易使用。Facade 不封裝子系統，只提供簡化的入口。

// 複雜子系統（客戶端不想逐一處理）
class CPU {
    public void freeze() { System.out.println("CPU 凍結"); }
    public void jump(long position) { System.out.println("跳到位址 " + position); }
    public void execute() { System.out.println("CPU 執行指令"); }
}
class Memory {
    public void load(long position, byte[] data) {
        System.out.println("記憶體載入 " + data.length + " bytes");
    }
}
class Disk {
    public byte[] read(long lba, int size) { return new byte[size]; }
}

// Facade：把複雜的開機流程封裝成一個方法
class Computer {
    private CPU    cpu    = new CPU();
    private Memory memory = new Memory();
    private Disk   disk   = new Disk();

    public void start() {          // 對外只有這一個方法
        cpu.freeze();
        memory.load(0x00, disk.read(0, 512));
        cpu.jump(0x00);
        cpu.execute();
        System.out.println("電腦啟動完成！");
    }
}

// 客戶端：完全不需要了解底層複雜性
new Computer().start();

運用共享技術有效地支援大量細粒度物件，透過將相同的「內部狀態」共享來大幅減少記憶體用量。

// 享元物件（共享的部分：樹的種類）
class TreeType {
    private final String name;   // 內部狀態（共享，不變）
    private final String color;

    public TreeType(String name, String color) {
        this.name = name; this.color = color;
    }

    // x, y 是外部狀態（每棵樹不同，由呼叫方提供）
    public void draw(int x, int y) {
        System.out.printf("在(%d,%d)種一棵%s(%s色)的樹%n", x, y, name, color);
    }
}

// 享元工廠（確保相同種類只創建一次）
class TreeFactory {
    private static Map<String, TreeType> pool = new HashMap<>();

    public static TreeType getTreeType(String name, String color) {
        String key = name + "_" + color;
        return pool.computeIfAbsent(key, k -> {
            System.out.println("新建享元: " + k);
            return new TreeType(name, color);
        });
    }
}

// 種一百萬棵樹，但 TreeType 物件只有幾個！
for (int i = 0; i < 1_000_000; i++) {
    TreeType oak = TreeFactory.getTreeType("橡樹", "綠"); // 從池中取
    oak.draw(i, i * 2);
}

為其他物件提供一種代理以控制對這個物件的訪問。代理物件與真實物件實現相同介面，讓客戶端透明地使用代理。

interface UserService {
    User getUser(int id);
}

// 真實物件
class RealUserService implements UserService {
    public User getUser(int id) {
        System.out.println("查詢資料庫 ID=" + id);
        return new User(id, "Andy");
    }
}

// 快取代理（不修改 RealUserService，增加快取邏輯）
class CachedUserService implements UserService {
    private final UserService real  = new RealUserService();
    private final Map<Integer, User> cache = new HashMap<>();

    public User getUser(int id) {
        if (cache.containsKey(id)) {
            System.out.println("返回快取 ID=" + id); // 攔截！
            return cache.get(id);
        }
        User user = real.getUser(id); // 委派給真實物件
        cache.put(id, user);
        return user;
    }
}

// Spring AOP 自動產生動態代理：
// @Transactional → Spring 包一層代理，在方法前後開啟/提交 Transaction
// @Cacheable     → Spring 包一層代理，自動做快取攔截

定義一系列演算法，把它們一個個封裝起來，並且使它們可以互相替換。使演算法可以獨立於使用它的客戶端而變化。

// 1. 策略介面
interface DiscountStrategy {
    double calculate(double price);
}

// 2. 具體策略
class VipDiscount implements DiscountStrategy {
    public double calculate(double p) { return p * 0.8; }  // 8折
}
class SeasonDiscount implements DiscountStrategy {
    public double calculate(double p) { return p - 50; }   // 折抵50
}
class NoDiscount implements DiscountStrategy {
    public double calculate(double p) { return p; }        // 無折扣
}

// 3. 上下文（不需知道具體策略實作）
class OrderService {
    private DiscountStrategy strategy;

    public void setStrategy(DiscountStrategy s) { this.strategy = s; }

    public double checkout(double price) {
        return strategy.calculate(price); // 委派給策略
    }
}

// Spring 進階：自動注入所有策略 Bean
@Service
class SmartOrderService {
    // Spring 自動掃描所有 DiscountStrategy 實作，以 BeanName 為 key 放入 Map
    @Autowired
    private Map<String, DiscountStrategy> strategies;

    public double checkout(String type, double price) {
        return strategies.get(type).calculate(price); // 不需一行 if-else！
    }
}

定義物件之間的一對多依賴關係，當一個物件狀態改變時，所有依賴它的物件都會自動被通知並更新。

// 方法一：原生 Java 實作
interface StockObserver {
    void onPriceChange(String stock, double price);
}

class StockMarket {
    private List<StockObserver> observers = new ArrayList<>();

    public void subscribe(StockObserver o)   { observers.add(o); }
    public void unsubscribe(StockObserver o) { observers.remove(o); }

    public void setPrice(String stock, double price) {
        System.out.println(stock + " 價格變動: " + price);
        observers.forEach(o -> o.onPriceChange(stock, price)); // 廣播通知
    }
}

// 方法二：Spring 事件（推薦）
@Service
class OrderService {
    @Autowired ApplicationEventPublisher publisher;

    public void createOrder(Order order) {
        // 核心業務...
        publisher.publishEvent(new OrderCreatedEvent(this, order)); // 發布
        // 不需知道有誰在監聽，完全解耦
    }
}

@Component class EmailListener {
    @EventListener                                    // 自動訂閱
    public void sendEmail(OrderCreatedEvent e) { /* ... */ }
}

@Component class InventoryListener {
    @EventListener
    @Async                                            // 可非同步
    public void deductStock(OrderCreatedEvent e) { /* ... */ }
}

將一個請求封裝成一個物件，從而使你可用不同的請求對客戶進行參數化，對請求排隊或記錄請求日誌，以及支援可撤銷的操作。

// 命令介面
interface Command {
    void execute();
    void undo();
}

// 接收者（真正執行工作的物件）
class TextEditor {
    private StringBuilder text = new StringBuilder();

    public void addText(String t)  { text.append(t); }
    public void deleteText(int n)  { text.delete(text.length()-n, text.length()); }
    public String getText()        { return text.toString(); }
}

// 具體命令（封裝動作 + 撤銷邏輯）
class TypeCommand implements Command {
    private TextEditor editor;
    private String typed;

    public TypeCommand(TextEditor e, String t) { editor = e; typed = t; }
    public void execute() { editor.addText(typed); }
    public void undo()    { editor.deleteText(typed.length()); }
}

// 調用者（持有命令歷史，不知道命令的具體細節）
class EditorController {
    private Deque<Command> history = new ArrayDeque<>();

    public void execute(Command cmd) {
        cmd.execute();
        history.push(cmd); // 記錄歷史
    }

    public void undo() {
        if (!history.isEmpty()) history.pop().undo(); // Ctrl+Z
    }
}

// 使用
EditorController ctrl = new EditorController();
ctrl.execute(new TypeCommand(editor, "Hello"));
ctrl.undo(); // 撤銷輸入

允許物件在內部狀態改變時改變它的行為，物件看起來好像修改了它的類別。用物件取代複雜的 if-else 狀態判斷。

// 狀態介面
interface OrderState {
    void pay(Order order);
    void ship(Order order);
    void cancel(Order order);
}

// 具體狀態（每個狀態知道自己能做什麼、不能做什麼）
class PendingState implements OrderState {
    public void pay(Order order) {
        System.out.println("付款成功！");
        order.setState(new PaidState()); // 狀態自行轉換
    }
    public void ship(Order order)   { System.out.println("尚未付款，無法出貨"); }
    public void cancel(Order order) { System.out.println("訂單已取消"); }
}

class PaidState implements OrderState {
    public void pay(Order order)  { System.out.println("已付款，請勿重複支付"); }
    public void ship(Order order) {
        System.out.println("出貨中...");
        order.setState(new ShippedState());
    }
    public void cancel(Order order) { System.out.println("退款處理中"); }
}

// 上下文（持有當前狀態，行為委派給狀態物件）
class Order {
    private OrderState state = new PendingState(); // 初始狀態

    public void setState(OrderState s) { this.state = s; }
    public void pay()    { state.pay(this); }   // 委派！不需要 if-else
    public void ship()   { state.ship(this); }
    public void cancel() { state.cancel(this); }
}

使多個物件都有機會處理請求，從而避免請求的發送者與接收者之間的耦合關係。將這些物件連成一條鏈，並沿著鏈傳遞請求直到有物件處理它。

// 抽象處理者
abstract class Approver {
    protected Approver next; // 鏈中的下一個處理者

    public Approver setNext(Approver next) {
        this.next = next;
        return next; // 支援鏈式設定
    }

    public abstract void approve(int amount);
}

// 具體處理者
class TeamLeader extends Approver {
    public void approve(int amount) {
        if (amount <= 1000) {
            System.out.println("組長批准 $" + amount);
        } else if (next != null) {
            next.approve(amount); // 超過權限，傳給下一個
        }
    }
}

class Manager extends Approver {
    public void approve(int amount) {
        if (amount <= 10000) {
            System.out.println("主管批准 $" + amount);
        } else if (next != null) {
            next.approve(amount);
        }
    }
}

class CEO extends Approver {
    public void approve(int amount) {
        System.out.println("CEO 批准 $" + amount); // 最終處理者
    }
}

// 建立責任鏈（鏈式設定）
Approver leader = new TeamLeader();
leader.setNext(new Manager()).setNext(new CEO());

leader.approve(500);     // 組長處理
leader.approve(5000);    // 傳到主管
leader.approve(500000);  // 傳到 CEO

提供一種方法順序訪問一個聚合物件中的各個元素，而不暴露該物件的內部表示。讓遍歷邏輯與集合結構解耦。

// Java 已內建迭代器，理解原理才能靈活使用

// 自定義集合實作 Iterable，就能用 for-each 語法
class NumberRange implements Iterable<Integer> {
    private int start, end;

    public NumberRange(int start, int end) {
        this.start = start; this.end = end;
    }

    @Override
    public Iterator<Integer> iterator() {
        return new Iterator<Integer>() {
            private int current = start;

            @Override public boolean hasNext() { return current <= end; }
            @Override public Integer next()    { return current++; }
        };
    }
}

// 現在可以用 for-each 遍歷自定義範圍
for (int n : new NumberRange(1, 5)) {
    System.out.print(n + " "); // 1 2 3 4 5
}

// Stream API 是迭代器的進化版（支援 lazy evaluation 與平行化）
IntStream.rangeClosed(1, 5)
         .filter(n -> n % 2 == 0)
         .forEach(System.out::println); // 2 4

用一個中介物件來封裝一系列物件的交互。中介者使各物件不需要顯示地互相引用，從而使其耦合鬆散，可以獨立地改變它們之間的交互。

// 中介者介面
interface ChatMediator {
    void sendMessage(String msg, User sender);
}

// 使用者（不直接與其他使用者溝通，只和中介者互動）
class User {
    private String name;
    private ChatMediator mediator;

    public User(String name, ChatMediator m) {
        this.name = name; this.mediator = m;
    }

    public void send(String msg) {
        System.out.println(name + " 發送: " + msg);
        mediator.sendMessage(msg, this); // 委派給中介者
    }

    public void receive(String msg) {
        System.out.println(name + " 收到: " + msg);
    }

    public String getName() { return name; }
}

// 中介者實作（聊天室）
class ChatRoom implements ChatMediator {
    private List<User> users = new ArrayList<>();

    public void join(User u) { users.add(u); }

    public void sendMessage(String msg, User sender) {
        users.stream()
             .filter(u -> u != sender)
             .forEach(u -> u.receive(msg)); // 轉發給所有其他人
    }
}

// 使用
ChatRoom room = new ChatRoom();
User alice = new User("Alice", room);
User bob   = new User("Bob",   room);
room.join(alice); room.join(bob);
alice.send("大家好！"); // Alice 不認識 Bob，但 ChatRoom 幫她廣播

在不破壞封裝性的前提下，捕獲一個物件的內部狀態，並在該物件之外儲存這個狀態，以便以後可以將物件恢復到這一狀態。

// 備忘錄（快照）—— 只有原發器能使用其細節
class GameSnapshot {
    private final int hp;
    private final int level;
    private final String position;

    GameSnapshot(int hp, int level, String pos) {
        this.hp = hp; this.level = level; this.position = pos;
    }

    // package-private：限制只有同套件內的 GameCharacter 能讀取
    int getHp()          { return hp; }
    int getLevel()       { return level; }
    String getPosition() { return position; }
}

// 原發器（負責創建與恢復快照）
class GameCharacter {
    private int hp = 100, level = 1;
    private String position = "起始點";

    public GameSnapshot save() { // 存檔
        return new GameSnapshot(hp, level, position);
    }

    public void restore(GameSnapshot snap) { // 讀檔
        this.hp       = snap.getHp();
        this.level    = snap.getLevel();
        this.position = snap.getPosition();
        System.out.println("讀取存檔：HP=" + hp + " Lv=" + level);
    }

    public void takeDamage(int d) { hp -= d; }
}

// 管理者（儲存快照，不了解快照內容）
class SaveManager {
    private Deque<GameSnapshot> saves = new ArrayDeque<>();

    public void save(GameSnapshot s) { saves.push(s); }
    public GameSnapshot undo()       { return saves.isEmpty() ? null : saves.pop(); }
}

定義一個操作中的演算法骨架，而將一些步驟延遲到子類中。使得子類可以不改變一個演算法的結構，即可重定義該演算法的某些特定步驟。

// 抽象類別定義固定的演算法骨架
abstract class DataExporter {

    // 範本方法（final 防止子類改變流程順序）
    public final void export(String filename) {
        System.out.println("=== 開始匯出 ===");
        List<Object> data = fetchData();           // 可變步驟 ↓
        validate(data);                            // 鉤子（有預設實作）
        String formatted = format(data);           // 可變步驟
        writeToFile(formatted, filename);          // 固定步驟
        System.out.println("=== 匯出完成: " + filename + " ===");
    }

    protected abstract List<Object> fetchData();
    protected abstract String format(List<Object> data);

    // 鉤子方法：子類可選擇性覆寫
    protected void validate(List<Object> data) {
        System.out.println("預設驗證：共 " + data.size() + " 筆");
    }

    private void writeToFile(String data, String f) {
        System.out.println("寫入: " + f);
    }
}

// 子類只實作差異部分，流程由父類控制
class CsvExporter extends DataExporter {
    protected List<Object> fetchData() { return List.of("Alice", "Bob"); }
    protected String format(List<Object> d) {
        return String.join(",", d.stream().map(Object::toString).toList());
    }
    // 不覆寫 validate() → 使用預設驗證
}

// JdbcTemplate 的設計原理相同：連線、執行SQL、映射結果是固定骨架
// 只有「執行什麼 SQL」和「如何映射結果」由你決定

在不改變各元素的類別的前提下，定義作用於這些元素的新操作。將演算法（操作）從資料結構（元素）中分離出來。

// 訪問者介面（每種元素對應一個 visit 方法）
interface ShapeVisitor {
    void visit(Circle circle);
    void visit(Rectangle rectangle);
}

// 元素介面
interface Shape {
    void accept(ShapeVisitor visitor); // 雙重分派的關鍵！
}

// 具體元素
class Circle implements Shape {
    double radius;
    Circle(double r) { this.radius = r; }
    public void accept(ShapeVisitor v) { v.visit(this); } // 呼叫對應重載
}

class Rectangle implements Shape {
    double width, height;
    Rectangle(double w, double h) { this.width = w; this.height = h; }
    public void accept(ShapeVisitor v) { v.visit(this); }
}

// 具體訪問者（新增操作不修改 Shape 類別）
class AreaCalculator implements ShapeVisitor {
    public void visit(Circle c) {
        System.out.println("圓形面積: " + (Math.PI * c.radius * c.radius));
    }
    public void visit(Rectangle r) {
        System.out.println("矩形面積: " + (r.width * r.height));
    }
}

// 使用
List<Shape> shapes = List.of(new Circle(5), new Rectangle(3, 4));
ShapeVisitor area = new AreaCalculator();
shapes.forEach(s -> s.accept(area)); // 雙重分派決定呼叫哪個 visit

給定一個語言，定義它的文法的一種表示，並定義一個解釋器，這個解釋器使用該文法表示來解釋語言中的句子。

// 表達式介面
interface Expression {
    int interpret();
}

// 終結符（Leaf）—— 數字
class NumberExpression implements Expression {
    private int value;
    public NumberExpression(int v) { this.value = v; }
    public int interpret() { return value; }
}

// 非終結符（Composite）—— 運算子
class AddExpression implements Expression {
    private Expression left, right;
    public AddExpression(Expression l, Expression r) { left = l; right = r; }
    public int interpret() { return left.interpret() + right.interpret(); }
}

class MultiplyExpression implements Expression {
    private Expression left, right;
    public MultiplyExpression(Expression l, Expression r) { left = l; right = r; }
    public int interpret() { return left.interpret() * right.interpret(); }
}

// 解析並計算算式：(3 + 5) × 2
Expression expr = new MultiplyExpression(
    new AddExpression(
        new NumberExpression(3),
        new NumberExpression(5)
    ),
    new NumberExpression(2)
);

System.out.println(expr.interpret()); // 輸出: 16

// 正規表達式、SpEL (Spring Expression Language) 都是此模式的成熟實作