设计模式举例

设计模式是软件开发中经过验证的解决方案，根据《设计模式：可复用面向对象软件的基础》一书，经典设计模式分为三大类，共 23 种。以下按类别列举并提供简单 Java 实现示例：

一、创建型模式（5 种）

专注于对象创建机制，隐藏创建逻辑。

1. 单例模式（Singleton）

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

java

运行

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

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

定义创建对象的接口，由子类决定实例化哪个类。

java

运行

// 产品接口
interface Product {void use();
}// 具体产品
class ConcreteProduct implements Product {@Overridepublic void use() {System.out.println("使用具体产品");}
}// 工厂接口
interface Factory {Product createProduct();
}// 具体工厂
class ConcreteFactory implements Factory {@Overridepublic Product createProduct() {return new ConcreteProduct();}
}// 使用
public class Main {public static void main(String[] args) {Factory factory = new ConcreteFactory();Product product = factory.createProduct();product.use();}
}

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

提供接口创建一系列相关 / 依赖对象，无需指定具体类。

java

运行

// 产品族接口
interface Chair { void sit(); }
interface Table { void put(); }// 具体产品（风格A）
class ModernChair implements Chair {@Override public void sit() { System.out.println("坐现代椅子"); }
}
class ModernTable implements Table {@Override public void put() { System.out.println("放现代桌子"); }
}// 抽象工厂
interface FurnitureFactory {Chair createChair();Table createTable();
}// 具体工厂（生产风格A）
class ModernFactory implements FurnitureFactory {@Override public Chair createChair() { return new ModernChair(); }@Override public Table createTable() { return new ModernTable(); }
}// 使用
public class Main {public static void main(String[] args) {FurnitureFactory factory = new ModernFactory();factory.createChair().sit();factory.createTable().put();}
}

4. 建造者模式（Builder）

分步构建复杂对象，分离构建与表示。

java

运行

class Computer {private String cpu;private String ram;public static class Builder {private String cpu;private String ram;public Builder cpu(String cpu) {this.cpu = cpu;return this;}public Builder ram(String ram) {this.ram = ram;return this;}public Computer build() {Computer computer = new Computer();computer.cpu = this.cpu;computer.ram = this.ram;return computer;}}
}// 使用
public class Main {public static void main(String[] args) {Computer computer = new Computer.Builder().cpu("i9").ram("32G").build();}
}

5. 原型模式（Prototype）

通过复制现有对象创建新对象。

java

运行

interface Prototype {Prototype clone();
}class ConcretePrototype implements Prototype {private String name;public ConcretePrototype(String name) {this.name = name;}@Overridepublic Prototype clone() {return new ConcretePrototype(this.name); // 浅克隆}
}// 使用
public class Main {public static void main(String[] args) {Prototype prototype = new ConcretePrototype("原型");Prototype clone = prototype.clone();}
}

二、结构型模式（7 种）

处理类或对象的组合，优化结构。

1. 适配器模式（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;}@Overridepublic void request() {adaptee.specificRequest(); // 适配}
}// 使用
public class Main {public static void main(String[] args) {Target target = new Adapter(new Adaptee());target.request();}
}

2. 装饰器模式（Decorator）

动态给对象添加额外职责。

java

运行

// 组件接口
interface Coffee {String getDescription();double cost();
}// 具体组件
class SimpleCoffee implements Coffee {@Override public String getDescription() { return "纯咖啡"; }@Override public double cost() { return 5; }
}// 装饰器抽象类
abstract class CoffeeDecorator implements Coffee {protected Coffee coffee;public CoffeeDecorator(Coffee coffee) {this.coffee = coffee;}
}// 具体装饰器（加牛奶）
class MilkDecorator extends CoffeeDecorator {public MilkDecorator(Coffee coffee) { super(coffee); }@Override public String getDescription() { return coffee.getDescription() + "+牛奶"; }@Override public double cost() { return coffee.cost() + 2; }
}// 使用
public class Main {public static void main(String[] args) {Coffee coffee = new MilkDecorator(new SimpleCoffee());System.out.println(coffee.getDescription() + "：" + coffee.cost() + "元");}
}

3. 代理模式（Proxy）

为对象提供代理以控制访问。

java

运行

// 主题接口
interface Image {void display();
}// 真实主题
class RealImage implements Image {private String filename;public RealImage(String filename) {this.filename = filename;loadFromDisk();}private void loadFromDisk() {System.out.println("加载图片：" + filename);}@Override public void display() {System.out.println("显示图片：" + filename);}
}// 代理
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();}
}// 使用
public class Main {public static void main(String[] args) {Image image = new ProxyImage("test.jpg");image.display(); // 首次加载并显示image.display(); // 直接显示（已加载）}
}

4. 外观模式（Facade）

为子系统提供统一接口，简化访问。

java

运行

// 子系统类
class SubSystemA { public void operationA() { System.out.println("子系统A操作"); } }
class SubSystemB { public void operationB() { System.out.println("子系统B操作"); } }// 外观类
class Facade {private SubSystemA a;private SubSystemB b;public Facade() {a = new SubSystemA();b = new SubSystemB();}public void doSomething() {a.operationA();b.operationB();}
}// 使用
public class Main {public static void main(String[] args) {Facade facade = new Facade();facade.doSomething(); // 一键调用多个子系统}
}

5. 桥接模式（Bridge）

将抽象与实现分离，使两者可独立变化。

java

运行

// 实现接口
interface Implementor {void operationImpl();
}// 具体实现
class ConcreteImplementorA implements Implementor {@Override public void operationImpl() { System.out.println("实现A"); }
}// 抽象类（桥接）
abstract class Abstraction {protected Implementor implementor;public Abstraction(Implementor implementor) {this.implementor = implementor;}public abstract void operation();
}// 扩展抽象类
class RefinedAbstraction extends Abstraction {public RefinedAbstraction(Implementor implementor) { super(implementor); }@Override public void operation() {implementor.operationImpl();}
}// 使用
public class Main {public static void main(String[] args) {Abstraction abstraction = new RefinedAbstraction(new ConcreteImplementorA());abstraction.operation();}
}

6. 组合模式（Composite）

将对象组合成树形结构，表示 “部分 - 整体” 关系。

java

运行

import java.util.ArrayList;
import java.util.List;// 组件抽象类
abstract class Component {protected String name;public Component(String name) { this.name = name; }public abstract void add(Component component);public abstract void remove(Component component);public abstract void display(int depth);
}// 叶子节点（无子节点）
class Leaf extends Component {public Leaf(String name) { super(name); }@Override public void add(Component component) {} // 空实现@Override public void remove(Component component) {}@Override public void display(int depth) {System.out.println("-".repeat(depth) + name);}
}// 容器节点（有子节点）
class Composite extends Component {private List<Component> children = new ArrayList<>();public Composite(String name) { super(name); }@Override public void add(Component component) { children.add(component); }@Override public void remove(Component component) { children.remove(component); }@Override public void display(int depth) {System.out.println("-".repeat(depth) + name);for (Component child : children) {child.display(depth + 2); // 递归显示子节点}}
}// 使用
public class Main {public static void main(String[] args) {Composite root = new Composite("根节点");root.add(new Leaf("叶子1"));Composite branch = new Composite("分支节点");branch.add(new Leaf("叶子2"));root.add(branch);root.display(1);}
}

7. 享元模式（Flyweight）

复用细粒度对象，减少内存消耗。

java

运行

import java.util.HashMap;
import java.util.Map;// 享元接口
interface Shape {void draw();
}// 具体享元（圆）
class Circle implements Shape {private String color;public Circle(String color) { this.color = color; }@Override public void draw() {System.out.println("绘制" + color + "圆");}
}// 享元工厂
class ShapeFactory {private static final Map<String, Shape> circleMap = new HashMap<>();public static Shape getCircle(String color) {Circle circle = (Circle) circleMap.get(color);if (circle == null) {circle = new Circle(color);circleMap.put(color, circle);System.out.println("创建" + color + "圆");}return circle;}
}// 使用
public class Main {public static void main(String[] args) {Shape redCircle1 = ShapeFactory.getCircle("红色");Shape redCircle2 = ShapeFactory.getCircle("红色"); // 复用已创建的redCircle1.draw();redCircle2.draw();}
}

三、行为型模式（11 种）

关注对象间的通信与职责分配。

1. 策略模式（Strategy）

定义算法族，使它们可互换。

java

运行

// 策略接口
interface Strategy {int calculate(int a, int b);
}// 具体策略（加法）
class AddStrategy implements Strategy {@Override public int calculate(int a, int b) { return a + b; }
}// 上下文（使用策略）
class Context {private Strategy strategy;public Context(Strategy strategy) { this.strategy = strategy; }public int execute(int a, int b) {return strategy.calculate(a, b);}
}// 使用
public class Main {public static void main(String[] args) {Context context = new Context(new AddStrategy());System.out.println(context.execute(1, 2)); // 3}
}

2. 观察者模式（Observer）

定义对象间一对多依赖，当一个对象变化时通知所有依赖者。

java

运行

import java.util.ArrayList;
import java.util.List;// 主题接口
interface Subject {void registerObserver(Observer o);void removeObserver(Observer o);void notifyObservers();
}// 观察者接口
interface Observer {void update(String message);
}// 具体主题
class ConcreteSubject implements Subject {private List<Observer> observers = new ArrayList<>();private String message;public void setMessage(String message) {this.message = message;notifyObservers(); // 状态变化时通知}@Override public void registerObserver(Observer o) { observers.add(o); }@Override public void removeObserver(Observer o) { observers.remove(o); }@Override public void notifyObservers() {for (Observer o : observers) {o.update(message);}}
}// 具体观察者
class ConcreteObserver implements Observer {private String name;public ConcreteObserver(String name) { this.name = name; }@Override public void update(String message) {System.out.println(name + "收到消息：" + message);}
}// 使用
public class Main {public static void main(String[] args) {ConcreteSubject subject = new ConcreteSubject();subject.registerObserver(new ConcreteObserver("观察者1"));subject.setMessage("新消息来了");}
}

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

定义算法骨架，子类实现具体步骤。

java

运行

// 抽象类（模板）
abstract class Game {// 模板方法（固定流程）public final void play() {initialize();startPlay();endPlay();}abstract void initialize();abstract void startPlay();abstract void endPlay();
}// 具体实现（足球）
class Football extends Game {@Override void initialize() { System.out.println("足球游戏初始化"); }@Override void startPlay() { System.out.println("足球游戏开始"); }@Override void endPlay() { System.out.println("足球游戏结束"); }
}// 使用
public class Main {public static void main(String[] args) {Game game = new Football();game.play(); // 执行固定流程}
}

4. 迭代器模式（Iterator）

提供遍历聚合对象元素的方法，无需暴露内部结构。

java

运行

import java.util.ArrayList;
import java.util.List;// 迭代器接口
interface Iterator {boolean hasNext();Object next();
}// 聚合接口
interface Aggregate {Iterator createIterator();
}// 具体聚合
class ConcreteAggregate implements Aggregate {private List<Object> items = new ArrayList<>();public void add(Object item) { items.add(item); }@Override public Iterator createIterator() {return new ConcreteIterator(this);}public Object get(int index) { return items.get(index); }public int size() { return items.size(); }
}// 具体迭代器
class ConcreteIterator implements Iterator {private ConcreteAggregate aggregate;private int index = 0;public ConcreteIterator(ConcreteAggregate aggregate) {this.aggregate = aggregate;}@Override public boolean hasNext() {return index < aggregate.size();}@Override public Object next() {return aggregate.get(index++);}
}// 使用
public class Main {public static void main(String[] args) {ConcreteAggregate aggregate = new ConcreteAggregate();aggregate.add("元素1");aggregate.add("元素2");Iterator iterator = aggregate.createIterator();while (iterator.hasNext()) {System.out.println(iterator.next());}}
}

5. 责任链模式（Chain of Responsibility）

使多个对象都有机会处理请求，形成链传递。

java

运行

// 处理者抽象类
abstract class Handler {protected Handler nextHandler;public void setNext(Handler handler) {this.nextHandler = handler;}public abstract void handleRequest(int request);
}// 具体处理者1（处理1-10）
class ConcreteHandler1 extends Handler {@Override public void handleRequest(int request) {if (request >= 1 && request <= 10) {System.out.println("处理者1处理：" + request);} else if (nextHandler != null) {nextHandler.handleRequest(request); // 传递给下一个}}
}// 具体处理者2（处理11-20）
class ConcreteHandler2 extends Handler {@Override public void handleRequest(int request) {if (request >= 11 && request <= 20) {System.out.println("处理者2处理：" + request);} else if (nextHandler != null) {nextHandler.handleRequest(request);}}
}// 使用
public class Main {public static void main(String[] args) {Handler h1 = new ConcreteHandler1();Handler h2 = new ConcreteHandler2();h1.setNext(h2); // 形成链h1.handleRequest(5);  // 处理者1处理h1.handleRequest(15); // 处理者2处理}
}

6. 命令模式（Command）

将请求封装为对象，使请求与执行者解耦。

java

运行

// 命令接口
interface Command {void execute();
}// 接收者（实际执行者）
class Receiver {public void action() {System.out.println("执行操作");}
}// 具体命令
class ConcreteCommand implements Command {private Receiver receiver;public ConcreteCommand(Receiver receiver) {this.receiver = receiver;}@Override public void execute() {receiver.action();}
}// 调用者
class Invoker {private Command command;public void setCommand(Command command) {this.command = command;}public void executeCommand() {command.execute();}
}// 使用
public class Main {public static void main(String[] args) {Receiver receiver = new Receiver();Command command = new ConcreteCommand(receiver);Invoker invoker = new Invoker();invoker.setCommand(command);invoker.executeCommand(); // 调用者触发命令}
}

7. 备忘录模式（Memento）

捕获对象状态并保存，以便后续恢复。

java

运行

// 备忘录（存储状态）
class Memento {private String state;public Memento(String state) { this.state = state; }public String getState() { return state; }
}// 原发器（创建/恢复备忘录）
class Originator {private String state;public void setState(String state) { this.state = state; }public Memento createMemento() { return new Memento(state); }public void restoreMemento(Memento memento) {this.state = memento.getState();}
}// 管理者（保存备忘录）
class CareTaker {private Memento memento;public void setMemento(Memento m) { memento = m; }public Memento getMemento() { return memento; }
}// 使用
public class Main {public static void main(String[] args) {Originator originator = new Originator();CareTaker careTaker = new CareTaker();originator.setState("状态1");careTaker.setMemento(originator.createMemento()); // 保存originator.setState("状态2");originator.restoreMemento(careTaker.getMemento()); // 恢复}
}

8. 状态模式（State）

允许对象在内部状态变化时改变行为，类似状态机。

java

运行

// 状态接口
interface State {void doAction(Context context);
}// 具体状态A
class StartState implements State {@Override public void doAction(Context context) {System.out.println("进入开始状态");context.setState(this);}
}// 具体状态B
class StopState implements State {@Override public void doAction(Context context) {System.out.println("进入停止状态");context.setState(this);}
}// 上下文（维护状态）
class Context {private State state;public void setState(State state) { this.state = state; }
}// 使用
public class Main {public static void main(String[] args) {Context context = new Context();State startState = new StartState();startState.doAction(context); // 切换到开始状态}
}

9. 访问者模式（Visitor）

在不修改元素类的前提下，定义对元素的新操作。

java

运行

import java.util.ArrayList;
import java.util.List;// 元素接口
interface Element {void accept(Visitor visitor);
}// 具体元素A
class ElementA implements Element {@Override public void accept(Visitor visitor) {visitor.visit(this);}
}// 访问者接口
interface Visitor {void visit(ElementA element);
}// 具体访问者
class ConcreteVisitor implements Visitor {@Override public void visit(ElementA element) {System.out.println("访问元素A");}
}// 对象结构
class ObjectStructure {private List<Element> elements = new ArrayList<>();public void add(Element element) { elements.add(element); }public void accept(Visitor visitor) {for (Element e : elements) {e.accept(visitor);}}
}// 使用
public class Main {public static void main(String[] args) {ObjectStructure structure = new ObjectStructure();structure.add(new ElementA());Visitor visitor = new ConcreteVisitor();structure.accept(visitor);}
}

10. 中介者模式（Mediator）

用中介者封装对象间的交互，减少直接依赖。

java

运行

import java.util.ArrayList;
import java.util.List;// 中介者接口
interface Mediator {void send(String message, Colleague colleague);
}// 同事抽象类
abstract class Colleague {protected Mediator mediator;public Colleague(Mediator mediator) {this.mediator = mediator;}
}// 具体同事A
class ColleagueA extends Colleague {public ColleagueA(Mediator mediator) { super(mediator); }public void send(String message) {mediator.send(message, this);}public void receive(String message) {System.out.println("同事A收到：" + message);}
}// 具体中介者
class ConcreteMediator implements Mediator {private ColleagueA colleagueA;private ColleagueB colleagueB;public void setColleagueA(ColleagueA a) { colleagueA = a; }public void setColleagueB(ColleagueB b) { colleagueB = b; }@Override public void send(String message, Colleague colleague) {if (colleague == colleagueA) {colleagueB.receive(message); // 转发给B} else {colleagueA.receive(message); // 转发给A}}
}// 具体同事B（类似A）
class ColleagueB extends Colleague {public ColleagueB(Mediator mediator) { super(mediator); }public void send(String message) { mediator.send(message, this); }public void receive(String message) { System.out.println("同事B收到：" + message); }
}// 使用
public class Main {public static void main(String[] args) {ConcreteMediator mediator = new ConcreteMediator();ColleagueA a = new ColleagueA(mediator);ColleagueB b = new ColleagueB(mediator);mediator.setColleagueA(a);mediator.setColleagueB(b);a.send("你好B"); // 通过中介者转发}
}

11. 解释器模式（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 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);}
}// 使用
public class Main {// 构建语法树public static Expression getMaleExpression() {Expression robert = new TerminalExpression("Robert");Expression john = new TerminalExpression("John");return new OrExpression(robert, john); // 或操作（省略OrExpression实现，类似And）}public static void main(String[] args) {Expression isMale = getMaleExpression();System.out.println(isMale.interpret("John")); // true}
}

总结

23 种设计模式各有适用场景，核心是 “解耦” 和 “复用”。实际开发中需根据业务场景灵活选择，避免过度设计。以上示例为简化版，实际应用可能需要更复杂的边界处理。