当前位置：首页 > news >正文

Java 23种设计模式的详细解析

news 2025/10/14 15:55:14

以下是Java 23种设计模式的详细解析，包含意图、特点、实现要点及代码演示，按创建型、结构型、行为型分类整理：

一、创建型模式（5种）

专注于对象创建机制，隐藏创建逻辑，提高灵活性。

1. 单例模式（Singleton）

意图：确保一个类仅有一个实例，并提供全局访问点。
特点：
- 唯一实例，全局可访问；
- 避免频繁创建销毁，节省资源；
- 需处理线程安全问题。
实现要点：
- 私有构造器阻止外部实例化；
- 静态方法/变量持有唯一实例。

// 饿汉式（线程安全，类加载时初始化）
public class Singleton {private static final Singleton INSTANCE = new Singleton();private Singleton() {} // 私有构造器public static Singleton getInstance() { return INSTANCE; }
}// 懒汉式（双重校验锁，延迟初始化）
public class LazySingleton {private static volatile LazySingleton instance;private LazySingleton() {}public static LazySingleton getInstance() {if (instance == null) {synchronized (LazySingleton.class) {if (instance == null) {instance = new LazySingleton();}}}return instance;}
}

2. 工厂模式（Factory）

意图：通过工厂类封装对象创建逻辑，客户端无需关注具体实现。
特点：
- 解耦对象创建与使用；
- 新增产品只需扩展工厂，符合开闭原则；
- 适用于产品类型较少的场景。
实现要点：
- 定义产品接口；
- 工厂类根据参数返回具体产品实例。

// 产品接口
interface Shape { void draw(); }// 具体产品
class Circle implements Shape {@Override public void draw() { System.out.println("画圆形"); }
}// 工厂类
class ShapeFactory {public Shape getShape(String type) {if (type.equalsIgnoreCase("CIRCLE")) return new Circle();return null;}
}// 使用
public class FactoryDemo {public static void main(String[] args) {ShapeFactory factory = new ShapeFactory();factory.getShape("CIRCLE").draw(); // 输出：画圆形}
}

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

意图：创建一系列相关或依赖的产品族，无需指定具体类。
特点：
- 针对“产品族”（如“现代家具”包含椅子、桌子）；
- 切换产品族只需更换工厂，客户端无需修改；
- 新增产品需修改工厂接口，灵活性较低。
实现要点：
- 抽象工厂定义产品族的创建方法；
- 具体工厂实现特定产品族的创建。

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

4. 建造者模式（Builder）

意图：分步构建复杂对象，分离构建过程与最终表示。
特点：
- 步骤清晰，支持定制对象的不同部件；
- 同一构建过程可生成不同产品；
- 由指挥者控制构建顺序。
实现要点：
- 建造者接口定义部件构建方法；
- 指挥者调用建造者方法完成组装。

// 产品
class Computer {private String cpu;private String ram;// getter/setter省略
}// 建造者接口
interface ComputerBuilder {void buildCpu();void buildRam();Computer getResult();
}// 具体建造者（高配电脑）
class HighEndBuilder implements ComputerBuilder {private Computer computer = new Computer();@Override public void buildCpu() { computer.setCpu("i9"); }@Override public void buildRam() { computer.setRam("32GB"); }@Override public Computer getResult() { return computer; }
}// 指挥者
class Director {public Computer construct(ComputerBuilder builder) {builder.buildCpu();builder.buildRam();return builder.getResult();}
}// 使用
public class BuilderDemo {public static void main(String[] args) {Computer computer = new Director().construct(new HighEndBuilder());System.out.println(computer.getCpu()); // 输出：i9}
}

5. 原型模式（Prototype）

意图：通过复制现有对象创建新对象，避免重复初始化。
特点：
- 简化创建流程，适合初始化耗时的对象；
- 分为浅拷贝（引用类型共享）和深拷贝（完全复制）；
- 无需知道类名即可创建对象。
实现要点：
- 实现Cloneable接口；
- 重写clone()方法实现复制逻辑。

class Sheep implements Cloneable {private String name;public Sheep(String name) { this.name = name; }@Override protected Sheep clone() throws CloneNotSupportedException {return (Sheep) super.clone(); // 浅拷贝}
}// 使用
public class PrototypeDemo {public static void main(String[] args) throws CloneNotSupportedException {Sheep original = new Sheep("多利");Sheep clone = original.clone();System.out.println(clone.name); // 输出：多利}
}

二、结构型模式（7种）

处理类或对象的组合，优化结构以实现功能复用。

6. 适配器模式（Adapter）

意图：将一个类的接口转换为客户端期望的另一个接口。
特点：
- 解决接口不兼容问题（如旧系统对接新系统）；
- 分为类适配器（继承）和对象适配器（组合，更灵活）；
- 不修改原有代码，符合开闭原则。
实现要点：
- 适配器实现目标接口；
- 内部持有适配者实例，转发请求。

// 目标接口
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(); }
}// 使用
public class AdapterDemo {public static void main(String[] args) {Target target = new Adapter(new Adaptee());target.request(); // 输出：适配者方法}
}

7. 装饰器模式（Decorator）

意图：动态给对象添加额外功能，不改变其结构。
特点：
- 比继承更灵活，可多层嵌套装饰；
- 装饰器与被装饰者实现同一接口，客户端透明；
- 适用于功能扩展频繁的场景（如IO流）。
实现要点：
- 装饰器抽象类实现组件接口，并持有组件实例；
- 具体装饰器扩展额外功能。

// 抽象组件
interface Coffee {String getDesc();double cost();
}// 具体组件（基础咖啡）
class SimpleCoffee implements Coffee {@Override public String getDesc() { return "纯咖啡"; }@Override public double cost() { return 5.0; }
}// 装饰器
class MilkDecorator extends CoffeeDecorator {public MilkDecorator(Coffee coffee) { super(coffee); }@Override public String getDesc() { return super.getDesc() + " + 牛奶"; }@Override public double cost() { return super.cost() + 2.0; }
}// 使用
public class DecoratorDemo {public static void main(String[] args) {Coffee coffee = new MilkDecorator(new SimpleCoffee());System.out.println(coffee.getDesc() + "：" + coffee.cost()); // 纯咖啡 + 牛奶：7.0}
}

8. 代理模式（Proxy）

意图：为对象提供代理，控制对原对象的访问。
特点：
- 代理与目标对象实现同一接口，客户端无感知；
- 可实现权限控制、延迟加载、日志记录等；
- 分为静态代理和动态代理（如JDK Proxy）。
实现要点：
- 代理类持有目标对象引用；
- 代理方法中添加额外逻辑后调用目标方法。

// 抽象主题
interface Image { void display(); }// 真实主题（耗时操作）
class RealImage implements Image {private String filename;public RealImage(String filename) { this.filename = filename; load(); }private void load() { System.out.println("加载图片：" + filename); }@Override public void display() { System.out.println("显示图片"); }
}// 代理类（延迟加载）
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 ProxyDemo {public static void main(String[] args) {Image image = new ProxyImage("photo.jpg");image.display(); // 首次：加载并显示；再次：直接显示}
}

9. 外观模式（Facade）

意图：为子系统提供统一接口，简化客户端访问。
特点：
- 封装子系统复杂性，提供“一站式”接口；
- 隔离客户端与子系统，降低耦合；
- 不改变子系统内部逻辑。
实现要点：
- 外观类持有子系统实例；
- 提供高层方法封装子系统交互。

// 子系统
class DVDPlayer { public void on() { System.out.println("DVD打开"); } }
class Projector { public void on() { System.out.println("投影仪打开"); } }// 外观类
class HomeTheaterFacade {private DVDPlayer dvd;private Projector projector;public HomeTheaterFacade(DVDPlayer dvd, Projector projector) {this.dvd = dvd;this.projector = projector;}public void watchMovie() {projector.on();dvd.on();}
}// 使用
public class FacadeDemo {public static void main(String[] args) {new HomeTheaterFacade(new DVDPlayer(), new Projector()).watchMovie();// 输出：投影仪打开 → DVD打开}
}

10. 桥接模式（Bridge）

意图：分离抽象与实现，使两者可独立变化。
特点：
- 解决抽象与实现的多对多继承问题（避免类爆炸）；
- 抽象层与实现层通过组合关联，而非继承；
- 适合跨维度扩展场景（如“形状”与“颜色”）。
实现要点：
- 抽象类持有实现接口的引用；
- 抽象类的方法通过实现接口完成。

// 实现接口（颜色）
interface Color { void apply(); }
class Red implements Color { @Override public void apply() { System.out.println("红色"); } }// 抽象类（形状）
abstract class Shape {protected Color color;public Shape(Color color) { this.color = color; }abstract void draw();
}// 具体抽象（圆形）
class Circle extends Shape {public Circle(Color color) { super(color); }@Override void draw() {System.out.print("画圆形，颜色：");color.apply();}
}// 使用
public class BridgeDemo {public static void main(String[] args) {new Circle(new Red()).draw(); // 输出：画圆形，颜色：红色}
}

11. 组合模式（Composite）

意图：将对象组合成树形结构，统一处理单个对象和组合对象。
特点：
- 树形结构中，叶子节点与组合节点统一接口；
- 支持递归遍历（如文件系统的文件与文件夹）；
- 客户端无需区分叶子与组合，操作一致。
实现要点：
- 抽象组件定义统一接口；
- 组合节点持有子组件列表，实现添加/删除/遍历。

// 抽象组件
interface Component {void operation();void add(Component c);
}// 叶子节点（文件）
class File implements Component {private String name;public File(String name) { this.name = name; }@Override public void operation() { System.out.println("文件：" + name); }@Override public void add(Component c) {} // 叶子不支持添加
}// 组合节点（文件夹）
class Folder implements Component {private List<Component> children = new ArrayList<>();private String name;public Folder(String name) { this.name = name; }@Override public void operation() {System.out.println("文件夹：" + name);children.forEach(Component::operation);}@Override public void add(Component c) { children.add(c); }
}// 使用
public class CompositeDemo {public static void main(String[] args) {Folder root = new Folder("根目录");root.add(new File("a.txt"));root.operation(); // 输出：文件夹：根目录 → 文件：a.txt}
}

12. 享元模式（Flyweight）

意图：共享细粒度对象，减少内存消耗。
特点：
- 区分“内部状态”（共享，如颜色）和“外部状态”（非共享，如位置）；
- 通过享元池管理共享对象，避免重复创建；
- 适合对象数量多、重复度高的场景（如围棋棋子）。
实现要点：
- 享元工厂负责创建和缓存享元对象；
- 外部状态通过方法参数传入。

// 享元接口
interface Shape { void draw(int x, int y); }// 具体享元（圆形）
class Circle implements Shape {private String color; // 内部状态public Circle(String color) { this.color = color; }@Override public void draw(int x, int y) { // 外部状态System.out.println("圆形(" + color + ") at (" + x + "," + y + ")");}
}// 享元工厂
class ShapeFactory {private static final Map<String, Shape> circles = new HashMap<>();public static Shape getCircle(String color) {return circles.computeIfAbsent(color, k -> {System.out.println("创建" + color + "圆形");return new Circle(color);});}
}// 使用
public class FlyweightDemo {public static void main(String[] args) {Shape red1 = ShapeFactory.getCircle("红色");Shape red2 = ShapeFactory.getCircle("红色"); // 复用red1.draw(10, 20); // 圆形(红色) at (10,20)}
}

三、行为型模式（11种）

关注对象间的通信、职责分配和行为交互。

13. 策略模式（Strategy）

意图：定义算法族，使其可互换，客户端可动态选择。
特点：
- 算法独立封装，易于扩展（新增策略只需实现接口）；
- 解决“if-else”过多导致的代码臃肿；
- 客户端需知道所有策略类。
实现要点：
- 策略接口定义算法方法；
- 上下文持有策略引用，动态切换策略。

// 策略接口
interface Payment { void pay(int amount); }// 具体策略（支付宝）
class Alipay implements Payment {@Override public void pay(int amount) { System.out.println("支付宝支付：" + amount); }
}// 上下文
class ShoppingCart {private Payment payment;public void setPayment(Payment payment) { this.payment = payment; }public void checkout(int amount) { payment.pay(amount); }
}// 使用
public class StrategyDemo {public static void main(String[] args) {ShoppingCart cart = new ShoppingCart();cart.setPayment(new Alipay());cart.checkout(100); // 输出：支付宝支付：100}
}

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

意图：定义算法骨架，子类实现具体步骤。
特点：
- 固定流程，灵活定制步骤（如游戏的初始化→开始→结束）；
- 父类调用子类方法（好莱坞原则：“别找我，我找你”）；
- 符合开闭原则（扩展步骤而非修改骨架）。
实现要点：
- 抽象父类定义模板方法（包含固定步骤）；
- 抽象方法由子类实现具体逻辑。

// 抽象模板
abstract class Game {abstract void initialize();abstract void start();// 模板方法（固定流程）public final void play() {initialize();start();}
}// 具体实现（足球）
class Football extends Game {@Override void initialize() { System.out.println("足球初始化"); }@Override void start() { System.out.println("足球开始"); }
}// 使用
public class TemplateDemo {public static void main(String[] args) {new Football().play(); // 输出：足球初始化 → 足球开始}
}

15. 观察者模式（Observer）

意图：对象间一对多依赖，当一个对象变化时通知所有依赖者。
特点：
- 松耦合：主题无需知道观察者细节；
- 支持动态添加/移除观察者；
- 适合事件驱动场景（如GUI事件、消息通知）。
实现要点：
- 主题维护观察者列表，提供注册/移除/通知方法；
- 观察者实现更新接口，接收主题通知。

// 主题接口
interface Subject {void register(Observer o);void notifyObservers(String msg);
}// 观察者接口
interface Observer { void update(String msg); }// 具体主题（公众号）
class WechatSubject implements Subject {private List<Observer> observers = new ArrayList<>();@Override public void register(Observer o) { observers.add(o); }@Override public void notifyObservers(String msg) {observers.forEach(o -> o.update(msg));}
}// 具体观察者（用户）
class User implements Observer {private String name;public User(String name) { this.name = name; }@Override public void update(String msg) {System.out.println(name + "收到：" + msg);}
}// 使用
public class ObserverDemo {public static void main(String[] args) {WechatSubject subject = new WechatSubject();subject.register(new User("张三"));subject.notifyObservers("新文章发布"); // 张三收到：新文章发布}
}

16. 迭代器模式（Iterator）

意图：提供遍历集合的统一接口，无需暴露内部结构。
特点：
- 客户端无需关心集合类型（列表、树等），通过迭代器遍历；
- 支持多种遍历方式（正向、反向）；
- 符合单一职责原则（集合负责存储，迭代器负责遍历）。
实现要点：
- 迭代器接口定义hasNext()和next()方法；
- 集合提供获取迭代器的方法。

// 迭代器接口
interface Iterator {boolean hasNext();Object next();
}// 集合接口
interface Container { Iterator getIterator(); }// 具体集合（名字列表）
class NameContainer implements Container {private String[] names = {"A", "B", "C"};@Override public Iterator getIterator() {return new NameIterator();}private class NameIterator implements Iterator {int index = 0;@Override public boolean hasNext() { return index < names.length; }@Override public Object next() { return names[index++]; }}
}// 使用
public class IteratorDemo {public static void main(String[] args) {Container container = new NameContainer();Iterator it = container.getIterator();while (it.hasNext()) { System.out.println(it.next()); } // A、B、C}
}

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

意图：将请求沿处理链传递，直到被处理。
特点：
- 发送者与接收者解耦，无需知道谁处理请求；
- 可动态调整链结构（如审批流程：组长→经理→总监）；
- 可能导致请求未被处理。
实现要点：
- 处理器持有下一个处理器引用；
- 每个处理器判断是否处理请求，否则传递给下一个。

// 抽象处理器
abstract class Handler {protected Handler next;public void setNext(Handler next) { this.next = next; }abstract void handle(int request);
}// 处理1-10
class Handler1 extends Handler {@Override void handle(int request) {if (request <= 10) System.out.println("Handler1处理：" + request);else if (next != null) next.handle(request);}
}// 处理11-20
class Handler2 extends Handler {@Override void handle(int request) {if (request <= 20) System.out.println("Handler2处理：" + request);else if (next != null) next.handle(request);}
}// 使用
public class ChainDemo {public static void main(String[] args) {Handler h1 = new Handler1();Handler h2 = new Handler2();h1.setNext(h2);h1.handle(5);  // Handler1处理：5h1.handle(15); // Handler2处理：15}
}

18. 命令模式（Command）

意图：将请求封装为对象，使请求可参数化、队列化或撤销。
特点：
- 解耦请求发送者与接收者（如遥控器与灯）；
- 支持命令排队、日志记录、事务回滚；
- 新增命令只需实现接口，扩展性好。
实现要点：
- 命令接口定义execute()方法；
- 具体命令持有接收者引用，调用其方法。

// 命令接口
interface Command { void execute(); }// 接收者（灯）
class Light {public void on() { System.out.println("灯亮"); }
}// 具体命令（开灯）
class LightOnCommand implements Command {private Light light;public LightOnCommand(Light light) { this.light = light; }@Override public void execute() { light.on(); }
}// 调用者（遥控器）
class Remote {private Command command;public void setCommand(Command command) { this.command = command; }public void press() { command.execute(); }
}// 使用
public class CommandDemo {public static void main(String[] args) {Remote remote = new Remote();remote.setCommand(new LightOnCommand(new Light()));remote.press(); // 输出：灯亮}
}

19. 备忘录模式（Memento）

意图：保存对象状态，以便后续恢复。
特点：
- 封装状态存储细节，原发器无需暴露内部状态；
- 适合游戏存档、编辑器撤销等场景；
- 需平衡内存开销（过多快照占用资源）。
实现要点：
- 备忘录存储原发器状态；
- 管理者负责保存和恢复备忘录。

// 备忘录
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 save() { return new Memento(state); }public void restore(Memento m) { state = m.getState(); }
}// 管理者
class CareTaker {private Memento memento;public void save(Memento m) { memento = m; }public Memento get() { return memento; }
}// 使用
public class MementoDemo {public static void main(String[] args) {Originator o = new Originator();CareTaker c = new CareTaker();o.setState("状态1");c.save(o.save()); // 保存o.setState("状态2");o.restore(c.get()); // 恢复为状态1}
}

20. 状态模式（State）

意图：允许对象在内部状态变化时改变行为，类似状态机。
特点：
- 将状态逻辑封装到不同状态类，避免“if-else”堆砌；
- 状态转换清晰，可由状态类或上下文控制；
- 适合状态较多且转换复杂的场景（如订单状态）。
实现要点：
- 状态接口定义行为方法；
- 上下文持有当前状态，委托状态对象处理行为。

// 状态接口
interface State { void doAction(Context context); }// 具体状态（开启）
class StartState 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 StateDemo {public static void main(String[] args) {Context context = new Context();new StartState().doAction(context); // 输出：系统开启}
}

21. 访问者模式（Visitor）

意图：在不修改对象结构的前提下，为对象添加新操作。
特点：
- 分离“数据结构”与“操作行为”，新操作只需新增访问者；
- 适合数据结构稳定但操作多变的场景（如报表统计）；
- 修改结构需修改所有访问者，灵活性低。
实现要点：
- 元素接口定义accept(Visitor)方法；
- 访问者接口定义对每个元素的操作方法。

// 元素接口
interface Element { void accept(Visitor v); }// 具体元素（员工A）
class EmployeeA implements Element {@Override public void accept(Visitor v) { v.visit(this); }
}// 访问者接口
interface Visitor { void visit(EmployeeA a); }// 具体访问者（计算工资）
class SalaryVisitor implements Visitor {@Override public void visit(EmployeeA a) {System.out.println("计算员工A工资");}
}// 使用
public class VisitorDemo {public static void main(String[] args) {Element e = new EmployeeA();e.accept(new SalaryVisitor()); // 输出：计算员工A工资}
}

22. 中介者模式（Mediator）

意图：用中介者封装对象间的交互，减少直接依赖。
特点：
- 将网状依赖转为星状依赖，降低复杂度；
- 集中管理交互逻辑，便于维护；
- 中介者可能成为“上帝类”，需避免逻辑过重。
实现要点：
- 中介者接口定义交互方法；
- 同事类持有中介者引用，通过中介者通信。

// 中介者接口
interface Mediator { void send(String msg, Colleague c); }// 同事类
abstract class Colleague {protected Mediator mediator;public Colleague(Mediator m) { mediator = m; }
}// 具体同事（用户1）
class User1 extends Colleague {public User1(Mediator m) { super(m); }public void send(String msg) { mediator.send(msg, this); }public void receive(String msg) { System.out.println("User1收到：" + msg); }
}// 具体中介者（聊天室）
class ChatMediator implements Mediator {private User1 u1;private User2 u2;@Override public void send(String msg, Colleague c) {if (c == u1) u2.receive(msg);else u1.receive(msg);}
}// 使用
public class MediatorDemo {public static void main(String[] args) {Mediator m = new ChatMediator();User1 u1 = new User1(m);User2 u2 = new User2(m);u1.send("你好"); // User2收到：你好}
}

23. 解释器模式（Interpreter）

意图：定义语言语法的解释器，用于解析特定格式的语句。
特点：
- 适合简单语法（如正则表达式、表达式计算）；
- 语法复杂时会导致类爆炸（如SQL解析）；
- 可扩展新语法规则。
实现要点：
- 抽象表达式定义解释方法；
- 终结符表达式处理基本语法单元，非终结符表达式处理组合语法。

// 抽象表达式
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 e1, e2;public OrExpression(Expression e1, Expression e2) {this.e1 = e1;this.e2 = e2;}@Override public boolean interpret(String context) {return e1.interpret(context) || e2.interpret(context);}
}// 使用
public class InterpreterDemo {public static void main(String[] args) {Expression expr = new OrExpression(new TerminalExpression("a"), new TerminalExpression("b"));System.out.println(expr.interpret("abc")); // true（含a）}
}