Java 设计模式入门：23种经典模式的应用场景与代码实现
设计模式是软件开发中解决常见问题的通用解决方案。在Java编程语言中，设计模式被广泛应用于各种应用程序中，以实现代码的可重用性、可维护性和可扩展性。本文将围绕Java语言，介绍23种经典设计模式的应用场景与代码实现。
1. 单例模式（Singleton）
应用场景：确保一个类只有一个实例，并提供一个全局访问点。
代码实现：
java
public class Singleton {
private static Singleton instance;
private Singleton() {}
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
2. 工厂模式（Factory Method）
应用场景：定义一个用于创建对象的接口，让子类决定实例化哪一个类。
代码实现：
java
interface Product {
void use();
}
class ConcreteProductA implements Product {
public void use() {
System.out.println("使用产品A");
}
}
class ConcreteProductB implements Product {
public void use() {
System.out.println("使用产品B");
}
}
class Factory {
public static Product createProduct(String type) {
if ("A".equals(type)) {
return new ConcreteProductA();
} else if ("B".equals(type)) {
return new ConcreteProductB();
}
return null;
}
}
3. 抽象工厂模式（Abstract Factory）
应用场景：创建相关或依赖对象的家族，而不需要明确指定具体类。
代码实现：
java
interface ProductA {
void use();
}
interface ProductB {
void use();
}
class ConcreteProductA implements ProductA {
public void use() {
System.out.println("使用产品A");
}
}
class ConcreteProductB implements ProductB {
public void use() {
System.out.println("使用产品B");
}
}
interface FactoryA {
ProductA createProductA();
ProductB createProductB();
}
class ConcreteFactoryA implements FactoryA {
public ProductA createProductA() {
return new ConcreteProductA();
}
public ProductB createProductB() {
return new ConcreteProductB();
}
}
4. 建造者模式（Builder）
应用场景：将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。
代码实现：
java
class Product {
private String partA;
private String partB;
public void setPartA(String partA) {
this.partA = partA;
}
public void setPartB(String partB) {
this.partB = partB;
}
@Override
public String toString() {
return "Product{" +
"partA='" + partA + ''' +
", partB='" + partB + ''' +
'}';
}
}
class Builder {
private Product product = new Product();
public Builder addPartA(String partA) {
product.setPartA(partA);
return this;
}
public Builder addPartB(String partB) {
product.setPartB(partB);
return this;
}
public Product build() {
return product;
}
}
5. 原型模式（Prototype）
应用场景：通过复制现有的实例来创建新的实例。
代码实现：
java
class Prototype implements Cloneable {
private String partA;
private String partB;
public Prototype(String partA, String partB) {
this.partA = partA;
this.partB = partB;
}
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
public String getPartA() {
return partA;
}
public String getPartB() {
return partB;
}
}
6. 适配器模式（Adapter）
应用场景：将一个类的接口转换成客户期望的另一个接口。
代码实现：
java
interface Target {
void request();
}
class Adaptee {
public void specificRequest() {
System.out.println("特定请求");
}
}
class Adapter implements Target {
private Adaptee adaptee;
public Adapter(Adaptee adaptee) {
this.adaptee = adaptee;
}
@Override
public void request() {
adaptee.specificRequest();
}
}
7. 桥接模式（Bridge）
应用场景：将抽象部分与实现部分分离，使它们都可以独立地变化。
代码实现：
java
interface Abstraction {
void operation();
}
class RefinedAbstraction implements Abstraction {
private Implementor implementor;
public RefinedAbstraction(Implementor implementor) {
this.implementor = implementor;
}
@Override
public void operation() {
implementor.operationImpl();
}
}
interface Implementor {
void operationImpl();
}
class ConcreteImplementorA implements Implementor {
@Override
public void operationImpl() {
System.out.println("实现A");
}
}
class ConcreteImplementorB implements Implementor {
@Override
public void operationImpl() {
System.out.println("实现B");
}
}
8. 组合模式（Composite）
应用场景：将对象组合成树形结构以表示部分整体层次结构。
代码实现：
java
interface Component {
void operation();
}
class Leaf implements Component {
@Override
public void operation() {
System.out.println("叶子节点操作");
}
}
class Composite implements Component {
private List<Component> children = new ArrayList<>();
public void add(Component child) {
children.add(child);
}
@Override
public void operation() {
for (Component child : children) {
child.operation();
}
}
}
9. 装饰者模式（Decorator）
应用场景：动态地给一个对象添加一些额外的职责。
代码实现：
java
interface Component {
void operation();
}
class ConcreteComponent implements Component {
@Override
public void operation() {
System.out.println("具体组件操作");
}
}
class Decorator implements Component {
private Component component;
public Decorator(Component component) {
this.component = component;
}
@Override
public void operation() {
component.operation();
}
}
class ConcreteDecoratorA extends Decorator {
public ConcreteDecoratorA(Component component) {
super(component);
}
@Override
public void operation() {
super.operation();
addedBehavior();
}
private void addedBehavior() {
System.out.println("装饰者A添加的操作");
}
}
10. 外观模式（Facade）
应用场景：提供一个统一的接口，用来访问子系统中的一群接口。
代码实现：
java
interface SubSystemA {
void operationA();
}
interface SubSystemB {
void operationB();
}
interface SubSystemC {
void operationC();
}
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();
}
}
11. 享元模式（Flyweight）
应用场景：运用共享技术有效地支持大量细粒度的对象。
代码实现：
java
class Flyweight {
private String intrinsicState;
public Flyweight(String intrinsicState) {
this.intrinsicState = intrinsicState;
}
public void operation(String extrinsicState) {
System.out.println("内部状态：" + intrinsicState);
System.out.println("外部状态：" + extrinsicState);
}
}
class FlyweightFactory {
private Map<String, Flyweight> flyweights = new HashMap<>();
public Flyweight getFlyweight(String key) {
Flyweight flyweight = flyweights.get(key);
if (flyweight == null) {
flyweight = new Flyweight(key);
flyweights.put(key, flyweight);
}
return flyweight;
}
}
12. 代理模式（Proxy）
应用场景：为其他对象提供一种代理以控制对这个对象的访问。
代码实现：
java
interface Subject {
void request();
}
class RealSubject implements Subject {
@Override
public void request() {
System.out.println("真实主题处理请求");
}
}
class Proxy implements Subject {
private RealSubject realSubject;
public Proxy(RealSubject realSubject) {
this.realSubject = realSubject;
}
@Override
public void request() {
beforeRequest();
realSubject.request();
afterRequest();
}
private void beforeRequest() {
System.out.println("请求前处理");
}
private void afterRequest() {
System.out.println("请求后处理");
}
}
13. 职责链模式（Chain of Responsibility）
应用场景：使多个对象都有机会处理请求，从而避免请求发送者和接收者之间的耦合关系。
代码实现：
java
interface Handler {
void handleRequest(int request);
}
class ConcreteHandlerA implements Handler {
private Handler nextHandler;
public void setNextHandler(Handler nextHandler) {
this.nextHandler = nextHandler;
}
@Override
public void handleRequest(int request) {
if (request < 10) {
System.out.println("处理请求：" + request);
} else {
nextHandler.handleRequest(request);
}
}
}
class ConcreteHandlerB implements Handler {
private Handler nextHandler;
public void setNextHandler(Handler nextHandler) {
this.nextHandler = nextHandler;
}
@Override
public void handleRequest(int request) {
if (request >= 10 && request < 20) {
System.out.println("处理请求：" + request);
} else {
nextHandler.handleRequest(request);
}
}
}
14. 命令模式（Command）
应用场景：将请求封装为一个对象，从而允许用户使用不同的请求、队列或日志请求，以及支持可撤销的操作。
代码实现：
java
interface Command {
void execute();
}
class ConcreteCommand implements Command {
private Receiver receiver;
public ConcreteCommand(Receiver receiver) {
this.receiver = receiver;
}
@Override
public void execute() {
receiver.action();
}
}
class Receiver {
public void action() {
System.out.println("执行请求");
}
}
class Invoker {
private Command command;
public void setCommand(Command command) {
this.command = command;
}
public void action() {
command.execute();
}
}
15. 解释器模式（Interpreter）
应用场景：为语言创建解释器，以便解释语言中的句子。
代码实现：
java
interface Expression {
boolean interpret(String context);
}
class TerminalExpression implements Expression {
private String data;
public TerminalExpression(String data) {
this.data = data;
}
@Override
public boolean interpret(String context) {
return context.contains(data);
}
}
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);
}
}
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);
}
}
16. 迭代器模式（Iterator）
应用场景：提供一种方法顺序访问一个聚合对象中各个元素，而又不暴露该对象的内部表示。
代码实现：
java
interface Iterator {
boolean hasNext();
Object next();
}
class ListIterator implements Iterator {
private List<Object> list;
private int index;
public ListIterator(List<Object> list) {
this.list = list;
this.index = 0;
}
@Override
public boolean hasNext() {
return index < list.size();
}
@Override
public Object next() {
return list.get(index++);
}
}
17. 中介者模式（Mediator）
应用场景：定义一个对象来封装一组对象之间的交互，使对象之间不需要显式地相互引用，从而降低它们之间的耦合。
代码实现：
java
interface Mediator {
void send(String message, Colleague colleague);
}
interface Colleague {
void send(String message, Mediator mediator);
void receive(String message);
}
class ConcreteMediator implements Mediator {
private Colleague colleagueA;
private Colleague colleagueB;
public void setColleagueA(Colleague colleagueA) {
this.colleagueA = colleagueA;
}
public void setColleagueB(Colleague colleagueB) {
this.colleagueB = colleagueB;
}
@Override
public void send(String message, Colleague colleague) {
if (colleague == colleagueA) {
colleagueB.receive(message);
} else {
colleagueA.receive(message);
}
}
}
class ConcreteColleagueA implements Colleague {
private Mediator mediator;
public ConcreteColleagueA(Mediator mediator) {
this.mediator = mediator;
}
@Override
public void send(String message, Mediator mediator) {
mediator.send(message, this);
}
@Override
public void receive(String message) {
System.out.println("A收到消息：" + message);
}
}
class ConcreteColleagueB implements Colleague {
private Mediator mediator;
public ConcreteColleagueB(Mediator mediator) {
this.mediator = mediator;
}
@Override
public void send(String message, Mediator mediator) {
mediator.send(message, this);
}
@Override
public void receive(String message) {
System.out.println("B收到消息：" + message);
}
}
18. 备忘录模式（Memento）
应用场景：在不暴露对象内部细节的情况下保存和恢复对象之前的状态。
代码实现：
java
class Memento {
private String state;
// ... 其他状态信息
}
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.state;
}
}
class Caretaker {
private List<Memento> mementoList = new ArrayList<>();
public void add(Memento state) {
mementoList.add(state);
}
public Memento get(int index) {
return mementoList.get(index);
}
}
19. 观察者模式（Observer）
应用场景：当一个对象的状态发生改变时，自动通知所有依赖于它的对象。
代码实现：
java
interface Observer {
void update(String message);
}
class ConcreteObserver implements Observer {
@Override
public void update(String message) {
System.out.println("观察者收到消息：" + message);
}
}
interface Subject {
void registerObserver(Observer observer);
void removeObserver(Observer observer);
void notifyObservers();
}
class ConcreteSubject implements Subject {
private List<Observer> observers = new ArrayList<>();
@Override
public void registerObserver(Observer observer) {
observers.add(observer);
}
@Override
public void removeObserver(Observer observer) {
observers.remove(observer);
}
@Override
public void notifyObservers() {
for (Observer observer : observers) {
observer.update("状态改变");
}
}
}
20. 状态模式（State）
应用场景：允许一个对象在其内部状态改变时改变它的行为。
代码实现：
java
interface State {
void handle();
}
class ConcreteStateA implements State {
@Override
public void handle() {
System.out.println("状态A");
}
}
class ConcreteStateB implements State {
@Override
public void handle() {
System.out.println("状态B");
}
}
class Context {
private State state;
public void setState(State state) {
this.state = state;
}
public void request() {
state.handle();
}
}
21. 策略模式（Strategy）
应用场景：定义一系列算法，把它们一个个封装起来，并使它们可互相替换。
代码实现：
java
interface Strategy {
void execute();
}
class ConcreteStrategyA implements Strategy {
@Override
public void execute() {
System.out.println("策略A");
}
}
class ConcreteStrategyB implements Strategy {
@Override
public void execute() {
System.out.println("策略B");
}
}
class Context {
private Strategy strategy;
public void setStrategy(Strategy strategy) {
this.strategy = strategy;
}
public void executeStrategy() {
strategy.execute();
}
}
22. 模板方法模式（Template Method）
应用场景：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。
代码实现：
java
abstract class AbstractClass {
public final void templateMethod() {
primitiveOperation1();
primitiveOperation2();
hook();
concreteOperation1();
concreteOperation2();
}
protected void primitiveOperation1() {
System.out.println("基本操作1");
}
protected void primitiveOperation2() {
System.out.println("基本操作2");
}
protected void hook() {
}
protected abstract void concreteOperation1();
protected abstract void concreteOperation2();
}
class ConcreteClass extends AbstractClass {
@Override
protected void concreteOperation1() {
System.out.println("具体操作1");
}
@Override
protected void concreteOperation2() {
System.out.println("具体操作2");
}
}
23. 访问者模式（Visitor）
应用场景：表示一个作用于某对象结构中的各元素的操作，它使你可以在不改变各元素类的前提下定义作用于这些元素的新操作。
代码实现：
```java
interface Visitor {
void visit(ConcreteElementA elementA);
void
Comments NOTHING