设计模式总结

以下是对各种热门设计模式实现逻辑的详细说明：

创建型模式 (Creational Patterns)

单例模式 (Singleton Pattern)

• 核心逻辑：
  • 私有化构造函数，防止外部直接实例化
  • 在类内部创建唯一实例，并提供静态方法获取该实例
  • 保证线程安全，通常使用双重检查锁定或静态内部类实现

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

工厂模式 (Factory Pattern)

• 核心逻辑：
  • 定义一个创建对象的接口，让子类决定实例化哪个类
  • 工厂方法将对象的创建延迟到子类执行
  • 客户端通过工厂接口创建对象，无需知道具体实现类

public abstract class Creator {
    public abstract Product factoryMethod();
    
    public void someOperation() {
        Product product = factoryMethod();
        // 使用产品对象
    }
}

public class ConcreteCreator extends Creator {
    public Product factoryMethod() {
        return new ConcreteProduct();
    }
}

建造者模式 (Builder Pattern)

• 核心逻辑：
  • 将复杂对象的构建过程分解为多个步骤
  • 使用 Builder 接口定义构建步骤
  • Director 类指导构建过程，ConcreteBuilder 实现具体构建逻辑

public class Director {
    private Builder builder;
    
    public void construct() {
        builder.buildPartA();
        builder.buildPartB();
        builder.buildPartC();
    }
}

public interface Builder {
    void buildPartA();
    void buildPartB();
    void buildPartC();
    Product getResult();
}

结构型模式 (Structural Patterns)

适配器模式 (Adapter Pattern)

• 核心逻辑：
  • 创建适配器类实现目标接口
  • 在适配器内部持有被适配者的实例
  • 将目标接口的调用转换为对被适配者接口的调用

public class Adapter implements Target {
    private Adaptee adaptee;
    
    public Adapter(Adaptee adaptee) {
        this.adaptee = adaptee;
    }
    
    public void request() {
        adaptee.specificRequest();
    }
}

装饰器模式 (Decorator Pattern)

• 核心逻辑：
  • 装饰器类和被装饰类实现相同的接口
  • 装饰器持有被装饰对象的引用
  • 在不改变原对象的基础上，动态地给对象添加新功能

public abstract class Decorator implements Component {
    protected Component component;
    
    public Decorator(Component component) {
        this.component = component;
    }
    
    public void operation() {
        component.operation();
    }
}

public class ConcreteDecorator extends Decorator {
    public ConcreteDecorator(Component component) {
        super(component);
    }
    
    public void operation() {
        super.operation();
        addedBehavior();
    }
    
    private void addedBehavior() {
        // 添加的新功能
    }
}

外观模式 (Facade Pattern)

• 核心逻辑：
  • 创建外观类封装子系统的复杂接口
  • 客户端通过外观类与子系统交互
  • 简化客户端使用复杂系统的难度

public class Facade {
    private Subsystem1 subsystem1;
    private Subsystem2 subsystem2;
    
    public Facade() {
        subsystem1 = new Subsystem1();
        subsystem2 = new Subsystem2();
    }
    
    public void operation() {
        subsystem1.operation1();
        subsystem2.operation2();
    }
}

行为型模式 (Behavioral Patterns)

观察者模式 (Observer Pattern)

• 核心逻辑：
  • 定义 [Subject](file://E:\Project\untitled1\src\main\java\Subject.java#L2-L6)（主题）和 [Observer](file://E:\Project\untitled1\src\main\java\Observer.java#L2-L4)（观察者）接口
  • 主题维护观察者列表，并提供添加/删除观察者的方法
  • 当主题状态改变时，通知所有注册的观察者

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

public interface Observer {
    void update(Object data);
}

public class ConcreteSubject implements Subject {
    private List<Observer> observers = new ArrayList<>();
    private Object state;
    
    public void setState(Object state) {
        this.state = state;
        notifyObservers();
    }
    
    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update(state);
        }
    }
}

策略模式 (Strategy Pattern)

• 核心逻辑：
  • 定义策略接口，封装不同的算法
  • 具体策略类实现该接口
  • 上下文类持有一个策略对象，并在运行时可以切换策略

public interface Strategy {
    void algorithm();
}

public class ConcreteStrategyA implements Strategy {
    public void algorithm() {
        // 算法A的实现
    }
}

public class Context {
    private Strategy strategy;
    
    public void setStrategy(Strategy strategy) {
        this.strategy = strategy;
    }
    
    public void execute() {
        strategy.algorithm();
    }
}

模板方法模式 (Template Method Pattern)

• 核心逻辑：
  • 在抽象类中定义算法骨架（模板方法）
  • 将具体步骤声明为抽象方法，由子类实现
  • 模板方法控制算法执行流程，防止子类修改算法结构

public abstract class AbstractClass {
    // 模板方法，定义算法骨架
    public final void templateMethod() {
        primitiveOperation1();
        primitiveOperation2();
        concreteOperation();
    }
    
    // 抽象方法，由子类实现
    protected abstract void primitiveOperation1();
    protected abstract void primitiveOperation2();
    
    // 具体方法，子类可以直接使用
    private void concreteOperation() {
        // 具体实现
    }
}

public class ConcreteClass extends AbstractClass {
    protected void primitiveOperation1() {
        // 具体实现
    }
    
    protected void primitiveOperation2() {
        // 具体实现
    }
}