【解锁编程智慧】揭秘面向对象中的24种经典设计模式

面向对象编程（OOP）是一种编程范式，它通过使用对象和类来组织代码。设计模式是面向对象编程中解决常见问题的解决方案，它们可以帮助开发者写出更可维护、可扩展和可复用的代码。在OOP中，有24种经典的设计模式，每种模式都针对特定的问题提供了一种解决方案。以下是对这24种设计模式的详细介绍。

1. 单例模式（Singleton）

单例模式确保一个类只有一个实例，并提供一个全局访问点。

public class Singleton {
    private static Singleton instance;

    private Singleton() {}

    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

2. 工厂方法模式（Factory Method）

工厂方法模式定义一个用于创建对象的接口，让子类决定实例化哪一个类。

public interface Factory {
    Product create();
}

public class ConcreteFactory implements Factory {
    public Product create() {
        return new ConcreteProduct();
    }
}

public class Product {
    // Product code and methods
}

3. 抽象工厂模式（Abstract Factory）

抽象工厂模式提供一个接口，用于创建相关或依赖对象的家族。

public interface AbstractFactory {
    ProductA createProductA();
    ProductB createProductB();
}

public class ConcreteFactory1 implements AbstractFactory {
    public ProductA createProductA() {
        return new ConcreteProductA1();
    }

    public ProductB createProductB() {
        return new ConcreteProductB1();
    }
}

4. 建造者模式（Builder）

建造者模式将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

public class Builder {
    public void buildPartA() {}
    public void buildPartB() {}
}

public class Director {
    private Builder builder;

    public Director(Builder builder) {
        this.builder = builder;
    }

    public void construct() {
        builder.buildPartA();
        builder.buildPartB();
    }
}

5. 原型模式（Prototype）

原型模式通过复制现有的实例来创建新的实例。

public class Prototype implements Cloneable {
    public Prototype clone() {
        try {
            return (Prototype) super.clone();
        } catch (CloneNotSupportedException e) {
            throw new AssertionError();
        }
    }
}

6. 适配器模式（Adapter）

适配器模式允许将一个类的接口转换成客户期望的另一个接口。

public class Target {
    public void request() {
        System.out.println("Target: specific request.");
    }
}

public class Adapter extends Target implements Adaptee {
    private Adaptee adaptee;

    public Adapter(Adaptee adaptee) {
        this.adaptee = adaptee;
    }

    public void specificRequest() {
        adaptee.request();
    }
}

7. 桥接模式（Bridge）

桥接模式将抽象部分与实现部分分离，使它们都可以独立地变化。

public abstract class Abstraction {
    protected Implementation implementation;

    public void setImplementation(Implementation implementation) {
        this.implementation = implementation;
    }

    public abstract void operation();
}

public class RefinedAbstraction extends Abstraction {
    public void operation() {
        implementation operationImpl();
    }
}

8. 组合模式（Composite）

组合模式允许你将对象组合成树形结构来表示部分-整体的层次结构。

public abstract class Component {
    public abstract void operation();
}

public class Leaf extends Component {
    public void operation() {
        System.out.println("Leaf operation");
    }
}

public class Composite extends Component {
    private List<Component> children = new ArrayList<>();

    public void add(Component child) {
        children.add(child);
    }

    public void operation() {
        for (Component child : children) {
            child.operation();
        }
    }
}

9. 装饰者模式（Decorator）

装饰者模式动态地给一个对象添加一些额外的职责，而不改变其接口。

public class Component {
    public void operation() {
        // Component operation
    }
}

public class Decorator extends Component {
    private Component component;

    public Decorator(Component component) {
        this.component = component;
    }

    public void operation() {
        component.operation();
        // Additional responsibilities
    }
}

10. 外观模式（Facade）

外观模式提供了一个统一的接口，用来访问子系统中的一群接口。

public class SubsystemA {
    public void operationA() {
        // Subsystem A operation
    }
}

public class SubsystemB {
    public void operationB() {
        // Subsystem B operation
    }
}

public class Facade {
    private SubsystemA subsystemA;
    private SubsystemB subsystemB;

    public Facade() {
        subsystemA = new SubsystemA();
        subsystemB = new SubsystemB();
    }

    public void operation() {
        subsystemA.operationA();
        subsystemB.operationB();
    }
}

11. 享元模式（Flyweight）

享元模式通过共享尽可能多的相似对象来减少内存的使用。

public class Flyweight {
    public void operation(String extrinsicState) {
        // Operation using extrinsic state
    }
}

public class FlyweightFactory {
    private Map<String, Flyweight> flyweights = new HashMap<>();

    public Flyweight getFlyweight(String key) {
        Flyweight result = flyweights.get(key);
        if (result == null) {
            result = new ConcreteFlyweight(key);
            flyweights.put(key, result);
        }
        return result;
    }
}

12. 代理模式（Proxy）

代理模式为其他对象提供一种代理以控制对这个对象的访问。

public interface Subject {
    void request();
}

public class RealSubject implements Subject {
    public void request() {
        // Real operation
    }
}

public class Proxy implements Subject {
    private RealSubject realSubject;

    public Proxy(RealSubject realSubject) {
        this.realSubject = realSubject;
    }

    public void request() {
        // Pre-processing
        realSubject.request();
        // Post-processing
    }
}

13. 职责链模式（Chain of Responsibility）

职责链模式使多个对象都有机会处理请求，从而避免了请求发送者和接收者之间的耦合关系。

public interface Handler {
    void handle(Request request);
}

public class ConcreteHandlerA implements Handler {
    public void handle(Request request) {
        // Handle request
    }
}

public class ConcreteHandlerB implements Handler {
    public void handle(Request request) {
        // Handle request
    }
}

14. 命令模式（Command）

命令模式将请求封装为一个对象，从而允许用户使用不同的请求、队列或日志请求，以及支持可撤销的操作。

public interface Command {
    void execute();
}

public class ConcreteCommand implements Command {
    private Receiver receiver;

    public ConcreteCommand(Receiver receiver) {
        this.receiver = receiver;
    }

    public void execute() {
        receiver.action();
    }
}

public class Receiver {
    public void action() {
        // Receiver action
    }
}

15. 解释器模式（Interpreter）

解释器模式为语言创建一个解释器，该解释器使用语法分析器来分析语言，并解释语言中的句子。

public interface Expression {
    boolean interpret(String context);
}

public class TerminalExpression implements Expression {
    private String data;

    public TerminalExpression(String data) {
        this.data = data;
    }

    public boolean interpret(String context) {
        return context.contains(data);
    }
}

16. 迭代器模式（Iterator）

迭代器模式提供了一种方法顺序访问一个聚合对象中各个元素，而又不暴露该对象的内部表示。

public interface Iterator {
    boolean hasNext();
    Object next();
}

public class ConcreteIterator implements Iterator {
    private List<Object> list;
    private int position;

    public ConcreteIterator(List<Object> list) {
        this.list = list;
        this.position = 0;
    }

    public boolean hasNext() {
        return position < list.size();
    }

    public Object next() {
        Object obj = list.get(position);
        position++;
        return obj;
    }
}

17. 中介者模式（Mediator）

中介者模式定义一个对象来封装一组对象之间的交互，使对象之间不需要显式地相互引用，从而降低它们之间的耦合。

public interface Mediator {
    void send(String message, Colleague colleague);
}

public class ConcreteMediator implements Mediator {
    private Colleague colleagueA;
    private Colleague colleagueB;

    public void send(String message, Colleague colleague) {
        if (colleague == colleagueA) {
            colleagueB.receive(message);
        } else {
            colleagueA.receive(message);
        }
    }
}

18. 备忘录模式（Memento）

备忘录模式捕获一个对象的内部状态，并在该对象之外保存这个状态，以便可以在之后恢复它。

public class Memento {
    private String state;

    public Memento(String state) {
        this.state = state;
    }

    public String getState() {
        return state;
    }
}

public class Originator {
    private String state;

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

    public Memento saveStateToMemento() {
        return new Memento(state);
    }

    public void getStateFromMemento(Memento memento) {
        state = memento.getState();
    }
}

19. 观察者模式（Observer）

观察者模式定义对象之间的一对多依赖关系，当一个对象改变状态时，所有依赖于它的对象都会得到通知并自动更新。

public interface Observer {
    void update(String message);
}

public class ConcreteObserver implements Observer {
    public void update(String message) {
        // Update observer
    }
}

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

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

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

20. 状态模式（State）

状态模式允许一个对象在其内部状态改变时改变它的行为。

public interface State {
    void handle(Context context);
}

public class ConcreteStateA implements State {
    public void handle(Context context) {
        // Handle context in state A
    }
}

public class Context {
    private State state;

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

    public void request() {
        state.handle(this);
    }
}

21. 策略模式（Strategy）

策略模式定义一系列算法，把它们一个个封装起来，并使它们可互相替换。

public interface Strategy {
    void execute();
}

public class ConcreteStrategyA implements Strategy {
    public void execute() {
        // Execute strategy A
    }
}

public class Context {
    private Strategy strategy;

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

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

22. 模板方法模式（Template Method）

模板方法模式定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。

public abstract class AbstractClass {
    public final void templateMethod() {
        primitiveOperation1();
        abstractMethod();
        primitiveOperation2();
    }

    protected abstract void abstractMethod();

    protected void primitiveOperation1() {
        // Implementation
    }

    protected void primitiveOperation2() {
        // Implementation
    }
}

23. 访问者模式（Visitor）

访问者模式表示一个作用于某对象结构中的各元素的操作，它使你可以在不改变各元素类的前提下定义作用于这些元素的新操作。

public interface Visitor {
    void visit(ConcreteElementA elementA);
    void visit(ConcreteElementB elementB);
}

public class ConcreteVisitor implements Visitor {
    public void visit(ConcreteElementA elementA) {
        // Visit element A
    }

    public void visit(ConcreteElementB elementB) {
        // Visit element B
    }
}

public abstract class Element {
    public abstract void accept(Visitor visitor);
}

public class ConcreteElementA extends Element {
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }
}

public class ConcreteElementB extends Element {
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }
}

24. 模板模式（Visitor）

模板模式表示一个作用于某对象结构中的各元素的操作，它使你可以在不改变各元素类的前提下定义作用于这些元素的新操作。

public interface Visitor {
    void visit(ConcreteElementA elementA);
    void visit(ConcreteElementB elementB);
}

public class ConcreteVisitor implements Visitor {
    public void visit(ConcreteElementA elementA) {
        // Visit element A
    }

    public void visit(ConcreteElementB elementB) {
        // Visit element B
    }
}

public abstract class Element {
    public abstract void accept(Visitor visitor);
}

public class ConcreteElementA extends Element {
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }
}

public class ConcreteElementB extends Element {
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }
}

以上就是面向对象编程中的24种经典设计模式的详细介绍。每种模式都有其特定的用途和优势，开发者可以根据实际需求选择合适的设计模式来提高代码的质量和可维护性。