版本：基于 Java 17 & Java 21 LTS

设计模式是前辈们针对特定问题的经典解决方案。掌握设计模式能让你的代码更优雅、可读且易于维护。本篇将通过 Java 现代语法，展示几种最常用的设计模式。

1. 单例模式 (Singleton)

单例模式确保一个类只有一个实例，并提供全局访问点。

现代写法：枚举单例 (推荐)

public enum ConfigManager {
    INSTANCE;
    
    private String apiUrl = "https://api.example.com";
    
    public String getApiUrl() { return apiUrl; }
}

// 使用方式
String url = ConfigManager.INSTANCE.getApiUrl();

优点：代码最简洁，天生线程安全，且能防止反射和反序列化破坏单例。

2. 工厂模式 (Factory)

隐藏对象创建逻辑，让代码依赖于接口而非具体实现。

public interface MessageService {
    void send(String msg);
}

public class EmailService implements MessageService {
    @Override public void send(String msg) { System.out.println("Email: " + msg); }
}

// 静态工厂方法 (现代 Java 常用)
public class ServiceFactory {
    public static MessageService getService(String type) {
        return switch (type) {
            case "email" -> new EmailService();
            default -> throw new IllegalArgumentException("Unknown type");
        };
    }
}

3. 观察者模式 (Observer)

定义对象间的一对多依赖，当一个对象状态改变时，所有依赖者都会收到通知。

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;

public class EventCenter {
    private final List<Consumer<String>> listeners = new ArrayList<>();

    public void subscribe(Consumer<String> listener) { listeners.add(listener); }
    public void notify(String event) { listeners.forEach(l -> l.accept(event)); }
}

// 使用
var center = new EventCenter();
center.subscribe(event -> System.out.println("收到事件: " + event));
center.notify("Java 21 发布了！");

4. 装饰器模式 (Decorator)

动态地给对象增加功能，比继承更灵活。

public interface Coffee { double cost(); }
public class SimpleCoffee implements Coffee { @Override public double cost() { return 10; } }

public class MilkDecorator implements Coffee {
    private final Coffee coffee;
    public MilkDecorator(Coffee coffee) { this.coffee = coffee; }
    
    @Override public double cost() { return coffee.cost() + 5; }
}

// 使用
Coffee myCoffee = new MilkDecorator(new SimpleCoffee());
System.out.println("总价: " + myCoffee.cost()); // 15

5. 策略模式 (Strategy)

定义一系列算法，并在运行时动态切换。

import java.util.function.BinaryOperator;

public class Calculator {
    public int calculate(int a, int b, BinaryOperator<Integer> strategy) {
        return strategy.apply(a, b);
    }
}

// 使用
var calc = new Calculator();
int sum = calc.calculate(10, 5, (x, y) -> x + y);
int product = calc.calculate(10, 5, (x, y) -> x * y);

本章小结

第十二篇我们学习了：

  1. 枚举单例的简洁与安全。

  2. 利用现代 switch 表达式实现工厂模式。

  3. 通过函数式编程简化观察者模式和策略模式。

  4. 装饰器模式带来的灵活性。

下一篇预告：现代框架实战 (Spring Boot 3 入门、Spring Cloud 架构思想)