常见设计模式之Java实现

引言

设计模式是软件工程中的一套被反复使用的、大家公认的、经过分类编目的代码设计经验的总结。它们是解决特定问题的模板，可以提高代码的可重用性、可读性和可维护性。本文将介绍Java中常见的20种设计模式，并提供具体的使用场景、设计模式的解释以及示例代码。

创建型模式

单例模式（Singleton）

使用场景：需要确保某个类只有一个实例，并且提供一个全局访问点。
解释：单例模式确保一个类只有一个实例，并提供一个全局访问点。
示例代码：

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

工厂方法模式（Factory Method）

使用场景：当需要创建对象的类很多时，可以使用工厂方法模式来封装对象的创建过程。
解释：定义一个用于创建对象的接口，让子类决定实例化哪一个类。
示例代码：

interface Product {void use();
}class ConcreteProduct implements Product {public void use() {// ...}
}abstract class Creator {abstract Product factoryMethod();
}class ConcreteCreator extends Creator {public Product factoryMethod() {return new ConcreteProduct();}
}

抽象工厂模式（Abstract Factory）

使用场景：当需要创建多个相关或依赖对象的家族时。
解释：提供一个创建一系列相关或相互依赖对象的接口，而不需要指定它们具体的类。
示例代码：

// 类似工厂方法模式，但增加了多个产品族的创建

建造者模式（Builder）

使用场景：当创建复杂对象时，需要逐步构建。
解释：将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。
示例代码：

class Product {// ...
}class Builder {private Product product = new Product();public Builder setPart1(String part1) {product.setPart1(part1);return this;}// ...public Product build() {return product;}
}

原型模式（Prototype）

使用场景：当创建新对象成本较高时，可以使用原型模式。
解释：通过拷贝现有的实例来创建新的实例，而不是通过新建。
示例代码：

class Prototype implements Cloneable {// ...public Object clone() {try {return super.clone();} catch (CloneNotSupportedException e) {e.printStackTrace();}return null;}
}

结构型模式

适配器模式（Adapter）

使用场景：当需要将一个类的接口转换成客户期望的另一个接口时。
解释：使原本由于接口不兼容而不能一起工作的类可以一起工作。
示例代码：

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

装饰器模式（Decorator）

使用场景：当需要动态地给一个对象添加额外的职责时。
解释：在不修改对象结构的情况下，动态地给对象添加职责。
示例代码：

interface Component {void operate();
}class ConcreteComponent implements Component {public void operate() {// ...}
}abstract class Decorator implements Component {protected Component component;public Decorator(Component component) {this.component = component;}public void operate() {component.operate();}
}class ConcreteDecoratorA extends Decorator {public ConcreteDecoratorA(Component component) {super(component);}public void operate() {super.operate();// 添加额外职责}
}

代理模式（Proxy）

使用场景：当需要控制对原始对象的访问时。
解释：为其他对象提供一个代替或占位符作为它的接口。
示例代码：

interface Subject {void request();
}class RealSubject implements Subject {public void request() {// ...}
}class Proxy implements Subject {private RealSubject realSubject;public Proxy() {this.realSubject = null;}public void request() {if (realSubject == null) {realSubject = new RealSubject();}realSubject.request();}
}

外观模式（Facade）

使用场景：当需要提供一个客户端可以访问系统的复杂接口的简化接口时。
解释：定义一个高层接口，使得子系统更容易使用。
示例代码：

interface SubSystem {void operation();
}class SubSystem0 implements SubSystem {public void operation() {// ...}
}class SubSystem1 implements SubSystem {public void operation() {// ...}
}class Facade {private SubSystem0 subSystem0 = new SubSystem0();private SubSystem1 subSystem1 = new SubSystem1();public void operation() {subSystem0.operation();subSystem1.operation();}
}

桥接模式（Bridge）

使用场景：当需要将抽象部分与它的实现部分分离，使它们可以独立地变化时。
解释：将抽象与实现解耦，让它们可以独立地变化。
示例代码：

abstract class Abstraction {protected Implementor implementor;public Abstraction(Implementor implementor) {this.implementor = implementor;}public void operation() {implementor.operationImpl();}
}interface Implementor {void operationImpl();
}class ConcreteImplementorA implements Implementor {public void operationImpl() {// ...}
}class RefinedAbstraction extends Abstraction {public RefinedAbstraction(Implementor implementor) {super(implementor);}// ...
}

组合模式（Composite）

使用场景：当需要将对象组合成树形结构以表示“部分-整体”的层次结构时。
解释：将对象组合成树形结构来表示“部分-整体”的层次结构。
示例代码：

interface Component {void operation();
}class Leaf implements Component {public void operation() {// ...}
}class Composite implements Component {private List<Component> children = new ArrayList<>();public void add(Component component) {children.add(component);}public void operation() {for (Component component : children) {component.operation();}}
}

享元模式（Flyweight）

使用场景：当需要减少创建大量相似对象时。
解释：通过共享来高效地支持大量细粒度的对象。
示例代码：

class Flyweight {private String intrinsicState;public Flyweight(String intrinsicState) {this.intrinsicState = intrinsicState;}public void operation(String extrinsicState) {// ...}
}class FlyweightFactory {private HashMap<String, Flyweight> flyweights = new HashMap<>();public Flyweight getFlyweight(String key) {if (!flyweights.containsKey(key)) {flyweights.put(key, new Flyweight(key));}return flyweights.get(key);}
}

行为型模式

策略模式（Strategy）

使用场景：当需要在运行时选择算法或行为时。
解释：定义一系列算法，把它们一个个封装起来，并使它们可互换。
示例代码：

interface Strategy {void algorithmInterface();
}class ConcreteStrategyA implements Strategy {public void algorithmInterface() {// ...}
}class Context {private Strategy strategy;public Context(Strategy strategy) {this.strategy = strategy;}public void executeStrategy() {strategy.algorithmInterface();}
}

模板方法模式（Template Method）

使用场景：当需要在方法中定义算法的框架，将一些步骤的实现延迟到子类中时。
解释：定义算法的骨架，将一些步骤的实现延迟到子类中。
示例代码：

abstract class AbstractClass {public void templateMethod() {step1();step2();step3();}public abstract void step2();public void step1() {// ...}public void step3() {// ...}
}class ConcreteClass extends AbstractClass {public void step2(){// ...}
}

观察者模式（Observer）

使用场景：当一个对象的改变需要同时改变其他对象，而不知道具体有多少对象待改变时。
解释：对象间存在一对多关系时，则使用观察者模式。
示例代码：

interface Observer {void update();
}interface Subject {void registerObserver(Observer o);void removeObserver(Observer o);void notifyObservers();
}class ConcreteSubject implements Subject {private List<Observer> observers = new ArrayList<>();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();}}
}class ConcreteObserver implements Observer {public void update() {// ...}
}

迭代器模式（Iterator）

使用场景：当需要访问一个聚合对象中的元素，而又不暴露其内部的表示时。
解释：提供一种顺序访问一个聚合对象中的各个元素的方法，而又不暴露其内部的表示。
示例代码：

interface Iterator {boolean hasNext();Object next();
}interface Aggregate {Iterator createIterator();
}class ConcreteIterator implements Iterator {private List items;private int position = 0;public ConcreteIterator(List items) {this.items = items;}public boolean hasNext() {return position < items.size();}public Object next() {return items.get(position++);}
}class ConcreteAggregate implements Aggregate {private List items = new ArrayList();public Iterator createIterator() {return new ConcreteIterator(items);}
}

中介者模式（Mediator）

使用场景：当系统中对象之间存在复杂的引用关系时。
解释：用一个中介对象来封装一系列对象之间的交互。
示例代码：

interface Mediator {void register(String colleague, Colleague colleague);void relay(String colleague);
}interface Colleague {void setMediator(Mediator mediator);void notify(String message);
}class ConcreteMediator implements Mediator {private Map<String, Colleague> colleagues = new HashMap<>();public void register(String colleague, Colleague colleague) {colleagues.put(colleague, colleague);}public void relay(String colleague, String event) {Colleague c = colleagues.get(colleague);// ...}
}class ConcreteColleagueA implements Colleague {private Mediator mediator;public void setMediator(Mediator mediator) {this.mediator = mediator;}public void notify(String message) {mediator.relay("ColleagueA", message);}
}

命令模式（Command）

使用场景：当需要将请求封装为一个对象，从而使用不同的请求、队列或日志请求时。
解释：将请求封装为一个对象，从而使你可用不同的请求、队列或日志来参数化其他对象。
示例代码：

interface Command {void execute();
}class Receiver {public void action() {// ...}
}class ConcreteCommand implements Command {private Receiver receiver;public ConcreteCommand(Receiver receiver) {this.receiver = receiver;}public void execute() {receiver.action();}
}class Invoker {private Command command;public void setCommand(Command command) {this.command = command;}public void executeCommand() {command.execute();}
}

责任链模式（Chain of Responsibility）

使用场景：当多个对象处理请求，但具体哪个对象处理该请求待运行时才能确定时。
解释：使多个对象都有机会处理请求。从而避免请求的发送者和接收者之间的耦合关系。
示例代码：

interface Handler {void handleRequest(Request request);
}class ConcreteHandler1 extends Handler {private Handler next;public void setNext(Handler next) {this.next = next;}public void handleRequest(Request request) {if (next != null) {next.handleRequest(request);}}
}class Request {// ...
}

备忘录模式（Memento）

使用场景：当需要保存和恢复对象的内部状态时。
解释：在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。
示例代码：

class Memento {private String state;public Memento(String state) {this.state = state;}public String getState() {return state;}
}class Originator {private String state;public Memento saveStateToMemento() {return new Memento(state);}public void getStateFromMemento(Memento memento) {state = memento.getState();}
}class Caretaker {private Memento memento;public void setMemento(Memento memento) {this.memento = memento;}public Memento getMemento() {return memento;}
}

状态模式（State）

使用场景：当一个对象的行为取决于它的状态，并且它的状态值在运行时改变时。
解释：允许对象在内部状态改变时改变它的行为。
示例代码：

interface State {void handle(StateContext context);
}class ConcreteStateA implements State {public void handle(StateContext context) {// ...}
}class StateContext {private State state;public StateContext(State state) {this.state = state;}public void handleState() {state.handle(this);}
}

访问者模式（Visitor）

使用场景：当需要对一个对象结构中的对象进行操作，而又不想让这些操作依赖于对象的类时。
解释：为一个对象结构（比如组合结构）增加新能力。
示例代码：

interface Element {void accept(Visitor visitor);
}class ConcreteElementA implements Element {public void accept(Visitor visitor) {visitor.visit(this);}
}interface Visitor {void visit(ConcreteElementA element);
}class ConcreteVisitor implements Visitor {public void visit(ConcreteElementA element) {// ...}
}