Java设计模式进阶：探索与应用

在Java编程的世界里，设计模式如同武林秘籍，掌握了它们，便能写出高效、可维护的代码。本文将带你深入探索Java设计模式的进阶应用，揭示其在实际项目中的妙用。

单例模式的进化

单例模式是最常见的设计模式之一，但其传统实现方式在多线程环境下存在隐患。如何进化？我们可以采用双重校验锁模式：

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;
    }
}

通过volatile关键字和双重校验锁，确保线程安全和性能兼顾。

观察者模式的灵活应用

观察者模式在事件驱动编程中尤为重要。Java提供了java.util.Observable和java.util.Observer接口，但它们不够灵活。我们可以自定义实现：

interface Observer {
    void update(Object event);
}

class Subject {
    private List<Observer> observers = new ArrayList<>();

    public void addObserver(Observer observer) {
        observers.add(observer);
    }

    public void notifyObservers(Object event) {
        for (Observer observer : observers) {
            observer.update(event);
        }
    }
}

class EventListener implements Observer {
    @Override
    public void update(Object event) {
        System.out.println("Event received: " + event);
    }
}

这样，我们可以在任何对象间建立灵活的观察者关系。

装饰者模式的巧妙运用

装饰者模式在不改变对象结构的前提下，动态地扩展对象功能。以Java I/O为例：

InputStream in = new FileInputStream("file.txt");
BufferedInputStream bufferedIn = new BufferedInputStream(in);
DataInputStream dataIn = new DataInputStream(bufferedIn);

int data = dataIn.readInt();

通过层层装饰，FileInputStream的功能被不断增强，代码却保持简洁。

策略模式的动态选择

策略模式允许在运行时动态选择算法。以排序为例：

interface SortingStrategy {
    void sort(int[] array);
}

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

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

class Context {
    private SortingStrategy strategy;

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

    public void sort(int[] array) {
        strategy.sort(array);
    }
}

根据需求动态切换排序策略，提升代码灵活性。

代理模式的深度解析

代理模式为对象提供一种代理，以控制对这个对象的访问。Java中的Proxy类和InvocationHandler接口提供了动态代理的实现：

interface Service {
    void perform();
}

class RealService implements Service {
    @Override
    public void perform() {
        System.out.println("Performing real service");
    }
}

class ProxyHandler implements InvocationHandler {
    private Object target;

    public ProxyHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Before method");
        Object result = method.invoke(target, args);
        System.out.println("After method");
        return result;
    }
}

public class ProxyDemo {
    public static void main(String[] args) {
        Service realService = new RealService();
        Service proxyService = (Service) Proxy.newProxyInstance(
            Service.class.getClassLoader(),
            new Class<?>[] {Service.class},
            new ProxyHandler(realService)
        );

        proxyService.perform();
    }
}

通过动态代理，我们可以在不修改原有代码的情况下，增加额外的逻辑。

Java设计模式的进阶应用不仅能提升代码质量，还能让编程过程更加灵活和高效。掌握这些进阶技巧，你将能在Java编程的道路上走得更远。继续探索，不断实践，设计模式的精髓将逐渐融入你的代码之中。