代码优化艺术：如何通过设计模式实现高效的功能模块

public class Singleton {
    // 私有构造函数，防止外部实例化
    private Singleton() {}

    // 静态私有实例
    private static Singleton instance;

    // 提供全局访问点
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

// 产品接口
interface Product {
    void use();
}

// 具体产品A
class ConcreteProductA implements Product {
    public void use() {
        System.out.println("Using Product A");
    }
}

// 具体产品B
class ConcreteProductB implements Product {
    public void use() {
        System.out.println("Using Product B");
    }
}

// 工厂接口
interface Factory {
    Product factoryMethod();
}

// 具体工厂A
class ConcreteFactoryA implements Factory {
    public Product factoryMethod() {
        return new ConcreteProductA();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Factory factory = new ConcreteFactoryA();
        Product product = factory.factoryMethod();
        product.use();
    }
}

// 策略接口
interface Strategy {
    void algorithmInterface();
}

// 具体策略A
class ConcreteStrategyA implements Strategy {
    public void algorithmInterface() {
        System.out.println("Algorithm A");
    }
}

// 具体策略B
class ConcreteStrategyB implements Strategy {
    public void algorithmInterface() {
        System.out.println("Algorithm B");
    }
}

// 上下文环境
class Context {
    private Strategy strategy;

    public Context(Strategy strategy) {
        this.strategy = strategy;
    }

    public void executeStrategy() {
        strategy.algorithmInterface();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Context context = new Context(new ConcreteStrategyA());
        context.executeStrategy();
        
        // 改变策略
        context = new Context(new ConcreteStrategyB());
        context.executeStrategy();
    }
}

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

// 具体观察者
class ConcreteObserver implements Observer {
    public void update(String message) {
        System.out.println("Received message: " + message);
    }
}

// 主题接口
interface Subject {
    void registerObserver(Observer o);
    void removeObserver(Observer o);
    void notifyObservers();
}

// 具体主题
class ConcreteSubject implements Subject {
    private List<Observer> observers = new ArrayList<>();
    private String state;

    public void registerObserver(Observer o) {
        observers.add(o);
    }

    public void removeObserver(Observer o) {
        observers.remove(o);
    }

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

    public void setState(String state) {
        this.state = state;
        notifyObservers();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        ConcreteSubject subject = new ConcreteSubject();
        Observer observer = new ConcreteObserver();
        subject.registerObserver(observer);
        subject.setState("Hello, World!");
        subject.removeObserver(observer);
    }
}