Java高级设计模式：观察者、策略与模板方法

概述

设计模式是软件开发中的最佳实践。本教程介绍观察者、策略和模板方法模式的使用。

1. 观察者模式

import java.util.*;

// 主题接口
interface Subject {
    void attach(Observer observer);
    void detach(Observer observer);
    void notifyObservers();
}

// 观察者接口
interface Observer {
    void update(String event);
}

// 具体主题
class EventManager implements Subject {
    private List<Observer> observers = new ArrayList<>();
    private String event;
    
    @Override
    public void attach(Observer observer) {
        observers.add(observer);
    }
    
    @Override
    public void detach(Observer observer) {
        observers.remove(observer);
    }
    
    @Override
    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update(event);
        }
    }
    
    public void setEvent(String event) {
        this.event = event;
        notifyObservers();
    }
}

// 具体观察者
class Logger implements Observer {
    @Override
    public void update(String event) {
        System.out.println("日志记录: " + event);
    }
}

class EmailNotifier implements Observer {
    @Override
    public void update(String event) {
        System.out.println("发送邮件: " + event);
    }
}

// 测试
public class ObserverPatternDemo {
    public static void main(String[] args) {
        EventManager manager = new EventManager();
        
        manager.attach(new Logger());
        manager.attach(new EmailNotifier());
        
        manager.setEvent("用户登录");
        manager.setEvent("数据更新");
    }
}

2. 策略模式

// 策略接口
interface SortStrategy {
    void sort(int[] array);
}

// 具体策略
class BubbleSort implements SortStrategy {
    @Override
    public void sort(int[] array) {
        System.out.println("使用冒泡排序");
        int n = array.length;
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (array[j] > array[j + 1]) {
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }
    }
}

class QuickSort implements SortStrategy {
    @Override
    public void sort(int[] array) {
        System.out.println("使用快速排序");
        quickSort(array, 0, array.length - 1);
    }
    
    private void quickSort(int[] array, int low, int high) {
        if (low < high) {
            int pivot = partition(array, low, high);
            quickSort(array, low, pivot - 1);
            quickSort(array, pivot + 1, high);
        }
    }
    
    private int partition(int[] array, int low, int high) {
        int pivot = array[high];
        int i = low - 1;
        for (int j = low; j < high; j++) {
            if (array[j] < pivot) {
                i++;
                int temp = array[i];
                array[i] = array[j];
                array[j] = temp;
            }
        }
        int temp = array[i + 1];
        array[i + 1] = array[high];
        array[high] = temp;
        return i + 1;
    }
}

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

// 测试
public class StrategyPatternDemo {
    public static void main(String[] args) {
        int[] array = {5, 2, 8, 1, 9};
        
        Sorter sorter = new Sorter(new BubbleSort());
        sorter.sort(array.clone());
        
        sorter.setStrategy(new QuickSort());
        sorter.sort(array.clone());
    }
}

3. 模板方法模式

// 抽象类
abstract class DataProcessor {
    // 模板方法
    public final void process() {
        readData();
        processData();
        writeData();
        log();
    }
    
    protected abstract void readData();
    protected abstract void processData();
    protected abstract void writeData();
    
    protected void log() {
        System.out.println("处理完成");
    }
}

// 具体实现
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文件");
    }
}

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文件");
    }
    
    @Override
    protected void log() {
        System.out.println("JSON处理完成");
    }
}

// 测试
public class TemplateMethodDemo {
    public static void main(String[] args) {
        DataProcessor csvProcessor = new CSVProcessor();
        csvProcessor.process();
        
        System.out.println("---");
        
        DataProcessor jsonProcessor = new JSONProcessor();
        jsonProcessor.process();
    }
}

4. 最佳实践

1. 观察者模式：用于事件驱动系统
2. 策略模式：用于算法可切换场景
3. 模板方法模式：用于固定算法骨架
4. 组合使用：多种模式可以组合使用
5. 适度使用：避免过度设计

总结

设计模式是软件开发中的重要工具。掌握观察者、策略和模板方法模式，可以编写更灵活、更可维护的代码。