Java设计模式：面向对象的智慧

概述

设计模式是解决软件设计问题的经典方案，它提供了可重用的解决方案。掌握设计模式可以提高代码的可维护性和可扩展性。

1. 单例模式

// 双重检查锁单例
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 enum SingletonEnum {
    INSTANCE;
    public void doSomething() {
        System.out.println("Singleton method");
    }
}

2. 工厂模式

public class ShapeFactory {
    public static Shape createShape(String type) {
        return switch (type.toLowerCase()) {
            case "circle" -> new Circle();
            case "rectangle" -> new Rectangle();
            case "triangle" -> new Triangle();
            default -> throw new IllegalArgumentException("Unknown shape: " + type);
        };
    }
}

3. 观察者模式

import java.util.*;

interface Subject {
    void registerObserver(Observer observer);
    void removeObserver(Observer observer);
    void notifyObservers();
}

interface Observer {
    void update(String message);
}

class NewsPublisher implements Subject {
    private List<Observer> observers = new ArrayList<>();
    private String news;

    @Override
    public void registerObserver(Observer observer) {
        observers.add(observer);
    }

    @Override
    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }

    @Override
    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update(news);
        }
    }

    public void publishNews(String news) {
        this.news = news;
        notifyObservers();
    }
}

class NewsSubscriber implements Observer {
    private String name;
    public NewsSubscriber(String name) { this.name = name; }
    @Override
    public void update(String message) {
        System.out.println(name + " 收到新闻: " + message);
    }
}

4. 策略模式

interface PaymentStrategy {
    void pay(double amount);
}

class CreditCardPayment implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        System.out.println("信用卡支付: " + amount);
    }
}

class AlipayPayment implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        System.out.println("支付宝支付: " + amount);
    }
}

class PaymentContext {
    private PaymentStrategy strategy;
    public PaymentContext(PaymentStrategy strategy) {
        this.strategy = strategy;
    }
    public void executePayment(double amount) {
        strategy.pay(amount);
    }
}

5. 模板方法模式

abstract class AbstractGame {
    public final void play() {
        initialize();
        startPlay();
        endPlay();
    }
    protected abstract void initialize();
    protected abstract void startPlay();
    protected abstract void endPlay();
}

class CricketGame extends AbstractGame {
    @Override
    protected void initialize() { System.out.println("初始化板球游戏"); }
    @Override
    protected void startPlay() { System.out.println("开始板球游戏"); }
    @Override
    protected void endPlay() { System.out.println("结束板球游戏"); }
}

最佳实践

1. 选择合适的模式：根据问题选择设计模式
2. 遵循SOLID原则：单一职责、开闭原则等
3. 避免过度设计：不要为了使用模式而使用模式
4. 文档化设计决策：说明为什么使用某个模式
5. 测试设计模式：确保模式实现正确

总结

设计模式是面向对象设计的经典解决方案，掌握常用的设计模式，可以提高代码的可维护性和可扩展性。