Java行为型模式详解

策略模式（Strategy）

定义一系列算法，将每个算法封装起来，使它们可以互换。

public interface PricingStrategy {
    BigDecimal calculatePrice(BigDecimal originalPrice);
}

public class NormalPricing implements PricingStrategy {
    @Override
    public BigDecimal calculatePrice(BigDecimal originalPrice) {
        return originalPrice;
    }
}

public class VIPPricing implements PricingStrategy {
    @Override
    public BigDecimal calculatePrice(BigDecimal originalPrice) {
        return originalPrice.multiply(new BigDecimal("0.8"));
    }
}

public class PromotionPricing implements PricingStrategy {
    @Override
    public BigDecimal calculatePrice(BigDecimal originalPrice) {
        return originalPrice.multiply(new BigDecimal("0.6"));
    }
}

public class ShoppingCart {
    private PricingStrategy strategy;

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

    public BigDecimal checkout(BigDecimal amount) {
        return strategy.calculatePrice(amount);
    }
}

// 使用
Cart cart = new ShoppingCart();
cart.setStrategy(new NormalPricing());
System.out.println(cart.checkout(new BigDecimal("100"))); // 100

cart.setStrategy(new VIPPricing());
System.out.println(cart.checkout(new BigDecimal("100"))); // 80

观察者模式（Observer）

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

public interface EventListener {
    void onEvent(String eventType, Object data);
}

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

    public void subscribe(String eventType, EventListener listener) {
        listeners.computeIfAbsent(eventType, k -> new ArrayList<>()).add(listener);
    }

    public void publish(String eventType, Object data) {
        listeners.getOrDefault(eventType, List.of())
            .forEach(listener -> listener.onEvent(eventType, data));
    }
}

public class OrderEventListener implements EventListener {
    @Override
    public void onEvent(String eventType, Object data) {
        System.out.println("订单事件: " + eventType + ", 数据: " + data);
    }
}

public class NotificationListener implements EventListener {
    @Override
    public void onEvent(String eventType, Object data) {
        System.out.println("发送通知: " + eventType);
    }
}

// 使用
EventBus eventBus = new EventBus();
eventBus.subscribe("order.created", new OrderEventListener());
eventBus.subscribe("order.created", new NotificationListener());

eventBus.publish("order.created", new Order("123456"));

模板方法模式（Template Method）

在父类中定义算法骨架，将某些步骤延迟到子类实现。

public abstract class DataProcessor {
    public final void process() {
        readData();
        processData();
        writeData();
    }

    protected abstract void readData();
    protected abstract void processData();
    protected abstract void writeData();
}

public class CSVProcessor extends DataProcessor {
    @Override
    protected void readData() { System.out.println("读取CSV数据"); }
    @Override
    protected void processData() { System.out.println("处理CSV数据"); }
    @Override
    protected void writeData() { System.out.println("写入CSV结果"); }
}

public class JSONProcessor extends DataProcessor {
    @Override
    protected void readData() { System.out.println("读取JSON数据"); }
    @Override
    protected void processData() { System.out.println("处理JSON数据"); }
    @Override
    protected void writeData() { System.out.println("写入JSON结果"); }
}

// 使用
DataProcessor csvProcessor = new CSVProcessor();
csvProcessor.process();

DataProcessor jsonProcessor = new JSONProcessor();
jsonProcessor.process();

责任链模式（Chain of Responsibility）

使多个对象都有机会处理请求，将这些对象连成链，沿链传递直到被处理。

public abstract class Handler {
    protected Handler next;

    public Handler setNext(Handler next) {
        this.next = next;
        return next;
    }

    public void handle(Request request) {
        if (canHandle(request)) {
            process(request);
        } else if (next != null) {
            next.handle(request);
        }
    }

    protected abstract boolean canHandle(Request request);
    protected abstract void process(Request request);
}

public class AuthHandler extends Handler {
    @Override
    protected boolean canHandle(Request request) {
        return request.getToken() != null;
    }

    @Override
    protected void process(Request request) {
        System.out.println("认证通过: " + request.getPath());
    }
}

public class RateLimitHandler extends Handler {
    @Override
    protected boolean canHandle(Request request) {
        return request.getPath().startsWith("/api");
    }

    @Override
    protected void process(Request request) {
        System.out.println("速率限制检查通过: " + request.getPath());
    }
}

// 构建责任链
Handler auth = new AuthHandler();
Handler rateLimit = new RateLimitHandler();
auth.setNext(rateLimit);

auth.handle(new Request("/api/users", "token123"));

迭代器模式（Iterator）

提供顺序访问聚合对象元素的方法，不暴露其内部表示。

public interface Iterator<T> {
    boolean hasNext();
    T next();
}

public interface Iterable<T> {
    Iterator<T> iterator();
}

public class BookShelf implements Iterable<String> {
    private List<String> books = new ArrayList<>();

    public void addBook(String book) { books.add(book); }

    @Override
    public Iterator<String> iterator() {
        return new Iterator<>() {
            private int index = 0;
            @Override public boolean hasNext() { return index < books.size(); }
            @Override public String next() { return books.get(index++); }
        };
    }
}

// 使用
BookShelf shelf = new BookShelf();
shelf.addBook("Java编程思想");
shelf.addBook("设计模式");
shelf.addBook("重构");

for (String book : shelf) {
    System.out.println(book);
}

状态模式（State）

允许对象在内部状态改变时改变其行为。

public interface OrderState {
    void next(OrderContext context);
    void cancel(OrderContext context);
    String getStatus();
}

public class NewState implements OrderState {
    @Override
    public void next(OrderContext context) { context.setState(new PaidState()); }
    @Override
    public void cancel(OrderContext context) { context.setState(new CancelledState()); }
    @Override public String getStatus() { return "新建"; }
}

public class PaidState implements OrderState {
    @Override
    public void next(OrderContext context) { context.setState(new ShippedState()); }
    @Override
    public void cancel(OrderContext context) { context.setState(new RefundState()); }
    @Override public String getStatus() { return "已支付"; }
}

public class OrderContext {
    private OrderState state = new NewState();

    public void setState(OrderState state) {
        this.state = state;
        System.out.println("状态变更: " + state.getStatus());
    }

    public void next() { state.next(this); }
    public void cancel() { state.cancel(this); }
}

// 使用
OrderContext order = new OrderContext();
order.next();   // 新建 -> 已支付
order.next();   // 已支付 -> 已发货

总结

行为型模式关注对象间的职责分配和算法封装。策略封装算法族，观察者实现松耦合通知，模板方法定义算法骨架，责任链解耦请求发送者和接收者。