18. 设计模式与面向对象基础

// DIP 正确示范：依赖接口而非具体实现
public class NotificationService {
    private final Sender sender;                  // 依赖抽象（由调用方注入）

    public NotificationService(Sender sender) { this.sender = sender; }

    public void send(String msg) { sender.deliver(msg); }
}

public interface Sender {
    void deliver(String msg);
}
public class EmailSender implements Sender {
    @Override public void deliver(String msg) { /* 发邮件 */ }
}

public class ConfigManager {
    private static volatile ConfigManager instance;   // volatile 禁止重排

    private ConfigManager() { }                        // 私有构造

    public static ConfigManager getInstance() {
        if (instance == null) {                        // 快速路径，无锁
            synchronized (ConfigManager.class) {
                if (instance == null) {                // 二次检查
                    instance = new ConfigManager();
                }
            }
        }
        return instance;
    }
}

// 工厂方法：把"实例化"推迟到子类
public abstract class Dialog {
    public void render() {
        Button ok = createButton();          // 调用工厂方法
        ok.onClick(() -> close());
        ok.paint();
    }
    protected abstract Button createButton();   // 工厂方法（钩子）
}

public class WindowsDialog extends Dialog {
    @Override protected Button createButton() {
        return new WindowsButton();          // 子类决定具体产品
    }
}
public class HtmlDialog extends Dialog {
    @Override protected Button createButton() {
        return new HtmlButton();
    }
}

class GUIFactory:                     # 抽象工厂接口
    def create_button(self): raise NotImplementedError
    def create_checkbox(self): raise NotImplementedError

class WindowsFactory(GUIFactory):
    def create_button(self): return WindowsButton()
    def create_checkbox(self): return WindowsCheckbox()

class MacFactory(GUIFactory):
    def create_button(self): return MacButton()
    def create_checkbox(self): return MacCheckbox()

public class HttpRequest {
    private final String url;         // 必填
    private final String method;      // 可选，默认 GET
    private final String body;        // 可选
    private final int timeout;        // 可选，默认 5000

    private HttpRequest(Builder b) {
        this.url = b.url; this.method = b.method;
        this.body = b.body; this.timeout = b.timeout;
    }

    public static class Builder {
        private String url;
        private String method = "GET";
        private String body = "";
        private int timeout = 5000;

        public Builder(String url) { this.url = url; }
        public Builder method(String m) { this.method = m; return this; }
        public Builder body(String b) { this.body = b; return this; }
        public Builder timeout(int t) { this.timeout = t; return this; }
        public HttpRequest build() { return new HttpRequest(this); }
    }
}

import copy

class Document:
    def __init__(self, title="", body="", styles=None):
        self.title, self.body = title, body
        self.styles = styles or {}

    def clone(self):                       # 原型方法：深拷贝
        return copy.deepcopy(self)

doc = Document("模板", "...")
copy_doc = doc.clone()                     # 成本远低于重新构造

// 老系统：用 XML 格式读取报表
public interface LegacyReportParser {
    XMLData parseXML(String path);
}

// 新系统期望：返回 JSON
public interface ModernReportParser {
    JSONData parse(String path);
}

// 适配器：把老实现包装成新接口
public class ReportAdapter implements ModernReportParser {
    private final LegacyReportParser legacy;

    public ReportAdapter(LegacyReportParser legacy) { this.legacy = legacy; }

    @Override
    public JSONData parse(String path) {
        XMLData xml = legacy.parseXML(path);
        return convert(xml);          // 内部做格式转换
    }
}

// 虚拟代理：Image 为共同接口，RealImage 是昂贵的真实实现
public class ProxyImage implements Image {
    private RealImage real;
    public void display() {
        if (real == null) real = new RealImage(path);   // 首次访问才加载
        real.display();
    }
}

// 以 Java I/O 为真实案例：new BufferedInputStream(new FileInputStream(...))
public interface DataSource {
    void writeData(String data);
    String readData();
}

public class FileDataSource implements DataSource {
    // 基础实现：写/读文件
}

public class EncryptionDecorator implements DataSource {
    private final DataSource wrappee;         // 被装饰对象
    public EncryptionDecorator(DataSource source) { this.wrappee = source; }

    @Override
    public void writeData(String data) {
        wrappee.writeData(encrypt(data));     // 写入前加密
    }
    @Override
    public String readData() {
        return decrypt(wrappee.readData());   // 读取后解密
    }
}

// 使用：new CompressionDecorator(new EncryptionDecorator(new FileDataSource()))

class Subject:
    def __init__(self):
        self._observers = []

    def attach(self, obs): self._observers.append(obs)

    def notify(self, event):                # 状态变化广播
        for obs in self._observers:
            obs.update(event)

class Logger:
    def update(self, event):
        print("[log]", event)

class Metrics:
    def update(self, event):
        print("[metric]", event)

subject = Subject()
subject.attach(Logger())
subject.attach(Metrics())
subject.notify("user.login")                 # 两个观察者同时收到事件

public interface SortStrategy {
    void sort(int[] arr);
}

public class QuickSort implements SortStrategy {
    @Override public void sort(int[] arr) { /* 快排 */ }
}
public class HeapSort implements SortStrategy {
    @Override public void sort(int[] arr) { /* 堆排 */ }
}

public class Sorter {
    private SortStrategy strategy;

    public Sorter(SortStrategy strategy) { this.strategy = strategy; }
    public void setStrategy(SortStrategy s) { this.strategy = s; }   // 运行时切换
    public void execute(int[] arr) { strategy.sort(arr); }
}

public abstract class DataMiner {
    // 模板方法：定义固定骨架
    public final void mine(String path) {
        openFile(path);        // 1. 打开文件
        extractData();         // 2. 提取数据（子类实现）
        parse();               // 3. 解析（子类实现）
        closeFile(path);       // 4. 关闭文件
    }
    protected abstract void extractData();   // 抽象步骤
    protected abstract void parse();

    private void openFile(String p) { /* 公共实现 */ }
    private void closeFile(String p) { /* 公共实现 */ }
}

public class CsvDataMiner extends DataMiner {
    @Override protected void extractData() { /* 按 CSV 拆分 */ }
    @Override protected void parse() { /* 解析列 */ }
}

class State:                                # 状态基类
    def next(self, order): raise NotImplementedError

class PendingState(State):                  # 待支付
    def next(self, order):
        print("支付成功，进入已支付状态")
        order.state = PaidState()

class PaidState(State):                     # 已支付
    def next(self, order):
        print("发货，进入已发货状态")
        order.state = ShippedState()

class ShippedState(State):                  # 已发货
    def next(self, order):
        print("签收，订单完成")
        order.state = DoneState()

class Order:
    def __init__(self):
        self.state = PendingState()         # 初始状态

    def advance(self):                      # 状态迁移由当前状态决定
        self.state.next(self)

order = Order()
order.advance()   # 支付成功
order.advance()   # 发货
order.advance()   # 完成