Java设计模式概述：23种经典模式入门

什么是设计模式

设计模式是针对软件设计中常见问题的可重用解决方案。它们不是可以直接使用的代码，而是解决特定问题的思路和模板。

设计原则

SOLID原则

// S - 单一职责原则（Single Responsibility Principle）
public class OrderService {
    public void createOrder(Order order) { /* 创建订单 */ }
}

public class OrderNotifier {
    public void sendConfirmation(Order order) { /* 发送通知 */ }
}

// O - 开闭原则（Open/Closed Principle）
public interface PaymentStrategy {
    void pay(BigDecimal amount);
}

public class AlipayStrategy implements PaymentStrategy {
    @Override
    public void pay(BigDecimal amount) { /* 支付宝支付 */ }
}

// L - 里氏替换原则（Liskov Substitution Principle）
// 子类必须能够替换父类
public class Rectangle {
    protected int width, height;
    public int area() { return width * height; }
}

public class Square extends Rectangle {
    @Override
    public void setWidth(int width) {
        this.width = width;
        this.height = width;
    }
}

// I - 接口隔离原则（Interface Segregation Principle）
public interface Readable { String read(); }
public interface Writable { void write(String data); }

public class FileReader implements Readable {
    @Override
    public String read() { return "file content"; }
}

// D - 依赖倒置原则（Dependency Inversion Principle）
public interface UserRepository {
    User findById(String id);
}

public class UserService {
    private final UserRepository repository;
    public UserService(UserRepository repository) {
        this.repository = repository;
    }
}

设计模式分类

创建型模式（5种）

处理对象创建机制，提高创建灵活性和复用性。

// 单例模式 - 保证一个类只有一个实例
public class Singleton {
    private static volatile Singleton instance;
    private Singleton() {}
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

// 工厂模式 - 定义创建对象的接口
public interface Animal { void speak(); }
public class Dog implements Animal {
    @Override
    public void speak() { System.out.println("汪汪"); }
}
public class Cat implements Animal {
    @Override
    public void speak() { System.out.println("喵喵"); }
}
public class AnimalFactory {
    public static Animal create(String type) {
        return switch (type) {
            case "dog" -> new Dog();
            case "cat" -> new Cat();
            default -> throw new IllegalArgumentException("未知类型");
        };
    }
}

// 建造者模式 - 分步构建复杂对象
public class User {
    private final String name;
    private final String email;
    private final int age;

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

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

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

User user = new User.Builder()
    .name("张三")
    .email("zhangsan@example.com")
    .age(25)
    .build();

结构型模式（7种）

处理类和对象的组合，形成更大的结构。

// 适配器模式 - 将一个接口转换为客户期望的接口
public interface JsonParser {
    String parse(Object obj);
}

public class XmlAdapter implements JsonParser {
    private final XmlParser xmlParser;

    public XmlAdapter(XmlParser xmlParser) {
        this.xmlParser = xmlParser;
    }

    @Override
    public String parse(Object obj) {
        String xml = xmlParser.toXml(obj);
        return xmlToJson(xml);
    }
}

// 装饰器模式 - 动态添加功能
public interface DataSource {
    void writeData(String data);
}

public class FileDataSource implements DataSource {
    private String filename;
    @Override
    public void writeData(String data) { /* 写文件 */ }
}

public class EncryptionDecorator implements DataSource {
    private DataSource wrapped;
    public EncryptionDecorator(DataSource source) { this.wrapped = source; }
    @Override
    public void writeData(String data) {
        String encrypted = encrypt(data);
        wrapped.writeData(encrypted);
    }
    private String encrypt(String data) { return Base64.getEncoder().encodeToString(data.getBytes()); }
}

行为型模式（11种）

处理对象间的通信和职责分配。

// 观察者模式 - 一对多依赖，对象状态变化时通知所有观察者
public interface Observer {
    void update(String event);
}

public class EventEmitter {
    private Map<String, List<Observer>> listeners = new HashMap<>();

    public void on(String event, Observer observer) {
        listeners.computeIfAbsent(event, k -> new ArrayList<>()).add(observer);
    }

    public void emit(String event) {
        listeners.getOrDefault(event, List.of()).forEach(o -> o.update(event));
    }
}

// 策略模式 - 定义算法族，使它们可互换
public interface SortStrategy {
    void sort(int[] array);
}

public class BubbleSort implements SortStrategy {
    @Override
    public void sort(int[] array) { /* 冒泡排序 */ }
}

public class QuickSort implements SortStrategy {
    @Override
    public void sort(int[] array) { /* 快速排序 */ }
}

public class Sorter {
    private SortStrategy strategy;
    public void setStrategy(SortStrategy strategy) { this.strategy = strategy; }
    public void sort(int[] array) { strategy.sort(array); }
}

// 模板方法模式 - 定义算法骨架，子类实现具体步骤
public abstract class DataMiner {
    public void mine() {
        openFile();
        extractData();
        parseData();
        analyzeData();
        closeFile();
    }
    protected abstract void openFile();
    protected abstract void extractData();
    protected abstract void parseData();
    protected void analyzeData() { /* 默认分析逻辑 */ }
    protected abstract void closeFile();
}

总结

设计模式不是银弹，要根据实际问题选择合适的模式。过度使用设计模式反而会增加复杂度。掌握SOLID原则比记住23种模式更重要。