[教程]揭秘Java24种命令模式：实战解析与案例分析

在Java编程中，设计模式是提高代码可重用性、可维护性和可扩展性的重要工具。命令模式（Command Pattern）是行为型设计模式之一，它将请求封装为一个对象，从而允许用户使用不同的请求、队列或日...

在Java编程中，设计模式是提高代码可重用性、可维护性和可扩展性的重要工具。命令模式（Command Pattern）是行为型设计模式之一，它将请求封装为一个对象，从而允许用户使用不同的请求、队列或日志请求，并支持可撤销的操作。本文将深入解析Java中的24种命令模式，并通过实战案例展示其应用。

1. 命令模式概述

命令模式是一种行为设计模式，它将请求封装为一个对象，从而允许用户使用不同的请求、队列或日志请求，并支持可撤销的操作。命令模式的主要目的是将调用操作的对象与知道如何实现该操作的对象解耦。

2. 命令模式的角色

命令模式涉及到以下角色：

• 客户端（Client）：创建一个具体命令（ConcreteCommand）对象并确定其接收者。
• 命令（Command）：声明了一个给所有具体命令类的抽象接口。
• 具体命令（ConcreteCommand）：定义一个接收者和行为之间的弱耦合；实现execute()方法，负责调用接收者的相应操作。
• 请求者（Invoker）：负责调用命令对象执行请求，相关的方法叫做行动方法。
• 接收者（Receiver）：负责具体实施和执行一个请求。

3. Java24种命令模式实战解析

3.1 单例模式（Singleton Pattern）

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

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

3.2 工厂模式（Factory Pattern）

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

public interface CarFactory { Car createCar();
}
public class BMWFactory implements CarFactory { public Car createCar() { return new BMW(); }
}
public class BenzFactory implements CarFactory { public Car createCar() { return new Benz(); }
}

3.3 抽象工厂模式（Abstract Factory Pattern）

抽象工厂模式提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。

public interface CarFactory { Engine createEngine(); Transmission createTransmission();
}
public class BMWFactory implements CarFactory { public Engine createEngine() { return new BMWEngine(); } public Transmission createTransmission() { return new BMWTransmission(); }
}
public class BenzFactory implements CarFactory { public Engine createEngine() { return new BenzEngine(); } public Transmission createTransmission() { return new BenzTransmission(); }
}

3.4 建造者模式（Builder Pattern）

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

public class Person { private String name; private int age; private String address; public static Builder builder() { return new Builder(); } public static class Builder { private String name; private int age; private String address; public Builder name(String name) { this.name = name; return this; } public Builder age(int age) { this.age = age; return this; } public Builder address(String address) { this.address = address; return this; } public Person build() { return new Person(this); } } private Person(Builder builder) { this.name = builder.name; this.age = builder.age; this.address = builder.address; }
}

3.5 原型模式（Prototype Pattern）

原型模式通过复制现有的实例来创建新的实例，从而避免直接实例化类。

public class Person implements Cloneable { private String name; private int age; public Person(String name, int age) { this.name = name; this.age = age; } @Override protected Object clone() throws CloneNotSupportedException { return super.clone(); }
}

3.6 适配器模式（Adapter Pattern）

适配器模式将一个类的接口转换成客户期望的另一个接口，使原本接口不兼容的类可以一起工作。

public interface Target { void request();
}
public class Adaptee { public void specificRequest() { System.out.println("Adaptee's specificRequest."); }
}
public class Adapter implements Target { private Adaptee adaptee; public Adapter(Adaptee adaptee) { this.adaptee = adaptee; } @Override public void request() { adaptee.specificRequest(); }
}

3.7 桥接模式（Bridge Pattern）

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

public interface Abstraction { void operation();
}
public class RefinedAbstraction implements Abstraction { private Implementor implementor; public RefinedAbstraction(Implementor implementor) { this.implementor = implementor; } @Override public void operation() { implementor.operationImpl(); }
}
public interface Implementor { void operationImpl();
}
public class ConcreteImplementorA implements Implementor { @Override public void operationImpl() { System.out.println("ConcreteImplementorA's operationImpl."); }
}
public class ConcreteImplementorB implements Implementor { @Override public void operationImpl() { System.out.println("ConcreteImplementorB's operationImpl."); }
}

3.8 组合模式（Composite Pattern）

组合模式将对象组合成树形结构以表示“部分-整体”的层次结构，使得用户对单个对象和组合对象的使用具有一致性。

public abstract class Component { public abstract void operation();
}
public class Leaf extends Component { @Override public void operation() { System.out.println("Leaf operation."); }
}
public class Composite extends Component { private List children = new ArrayList<>(); @Override public void operation() { for (Component child : children) { child.operation(); } } public void add(Component child) { children.add(child); } public void remove(Component child) { children.remove(child); }
}

3.9 装饰器模式（Decorator Pattern）

装饰器模式动态地给一个对象添加一些额外的职责，就增加功能来说，装饰器模式比生成子类更为灵活。

public interface Component { void operation();
}
public class ConcreteComponent implements Component { @Override public void operation() { System.out.println("ConcreteComponent's operation."); }
}
public class Decorator implements Component { private Component component; public Decorator(Component component) { this.component = component; } @Override public void operation() { component.operation(); }
}
public class ConcreteDecoratorA extends Decorator { public ConcreteDecoratorA(Component component) { super(component); } @Override public void operation() { super.operation(); addedBehavior(); } private void addedBehavior() { System.out.println("ConcreteDecoratorA's addedBehavior."); }
}

3.10 外观模式（Facade Pattern）

外观模式提供了一个统一的接口，用来访问子系统中的一群接口，从而简化了客户端的调用。

public interface SubSystemA { void operationA();
}
public interface SubSystemB { void operationB();
}
public interface SubSystemC { void operationC();
}
public class Facade { private SubSystemA subSystemA; private SubSystemB subSystemB; private SubSystemC subSystemC; public Facade() { subSystemA = new SubSystemA(); subSystemB = new SubSystemB(); subSystemC = new SubSystemC(); } public void operation() { subSystemA.operationA(); subSystemB.operationB(); subSystemC.operationC(); }
}

3.11 享元模式（Flyweight Pattern）

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

public interface Flyweight { void operation(String extrinsicState);
}
public class ConcreteFlyweight implements Flyweight { private String intrinsicState; public ConcreteFlyweight(String intrinsicState) { this.intrinsicState = intrinsicState; } @Override public void operation(String extrinsicState) { System.out.println("Intrinsic State: " + intrinsicState + ", Extrinsic State: " + extrinsicState); }
}
public class FlyweightFactory { private Map flyweights = new HashMap<>(); public Flyweight getFlyweight(String key) { Flyweight flyweight = flyweights.get(key); if (flyweight == null) { flyweight = new ConcreteFlyweight(key); flyweights.put(key, flyweight); } return flyweight; }
}

3.12 代理模式（Proxy Pattern）

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

public interface Image { void display();
}
public class RealImage implements Image { private String fileName; public RealImage(String fileName) { this.fileName = fileName; loadImageFromDisk(); } @Override public void display() { System.out.println("Displaying " + fileName); } private void loadImageFromDisk() { System.out.println("Loading " + fileName + " from disk."); }
}
public class ProxyImage implements Image { private RealImage realImage; private String fileName; public ProxyImage(String fileName) { this.fileName = fileName; } @Override public void display() { if (realImage == null) { realImage = new RealImage(fileName); } realImage.display(); }
}

3.13 责任链模式（Chain of Responsibility Pattern）

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

public interface Handler { void handle(Request request);
}
public class ConcreteHandlerA implements Handler { private Handler nextHandler; public void setNextHandler(Handler nextHandler) { this.nextHandler = nextHandler; } @Override public void handle(Request request) { if (request.getType() == Type.A) { System.out.println("ConcreteHandlerA handles request."); } else { if (nextHandler != null) { nextHandler.handle(request); } } }
}
public class ConcreteHandlerB implements Handler { private Handler nextHandler; public void setNextHandler(Handler nextHandler) { this.nextHandler = nextHandler; } @Override public void handle(Request request) { if (request.getType() == Type.B) { System.out.println("ConcreteHandlerB handles request."); } else { if (nextHandler != null) { nextHandler.handle(request); } } }
}
public class HandlerChain { private Handler handlerA; private Handler handlerB; public HandlerChain() { handlerA = new ConcreteHandlerA(); handlerB = new ConcreteHandlerB(); handlerA.setNextHandler(handlerB); } public void handleRequest(Request request) { handlerA.handle(request); }
}

3.14 解释器模式（Interpreter Pattern）

解释器模式为语言创建解释器，用于解释表达式。

public interface Expression { boolean interpret(String context);
}
public class TerminalExpression implements Expression { private String data; public TerminalExpression(String data) { this.data = data; } @Override public boolean interpret(String context) { return context.contains(data); }
}
public class OrExpression implements Expression { private Expression expr1; private Expression expr2; public OrExpression(Expression expr1, Expression expr2) { this.expr1 = expr1; this.expr2 = expr2; } @Override public boolean interpret(String context) { return expr1.interpret(context) || expr2.interpret(context); }
}
public class AndExpression implements Expression { private Expression expr1; private Expression expr2; public AndExpression(Expression expr1, Expression expr2) { this.expr1 = expr1; this.expr2 = expr2; } @Override public boolean interpret(String context) { return expr1.interpret(context) && expr2.interpret(context); }
}

3.15 迭代器模式（Iterator Pattern）

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

public interface Iterator { boolean hasNext(); Object next();
}
public class ListIterator implements Iterator { private List