Java设计模式概览

Java 设计模式详解

一、设计模式概述

1. 为什么需要设计模式

• 提供通用的解决方案，避免重复造轮子
• 提高代码的可重用性和可维护性
• 促进团队间的沟通（使用模式名称即可表达复杂思想）
• 帮助开发者编写更灵活、可扩展的代码

2. 设计模式分类

• 创建型模式：处理对象创建机制
• 结构型模式：处理类和对象的组合
• 行为型模式：处理对象间的通信

二、创建型模式 (5种)

1. 单例模式 (Singleton)

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

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

变体：

• 饿汉式（类加载时就初始化）
• 懒汉式（双重检查锁定）
• 静态内部类实现
• 枚举实现（最安全）

应用场景：

• 配置管理器
• 连接池
• 日志对象

2. 工厂方法模式 (Factory Method)

目的：定义一个创建对象的接口，但让子类决定实例化哪个类

public interface Product {void use();
}public class ConcreteProduct implements Product {public void use() {System.out.println("Using ConcreteProduct");}
}public abstract class Creator {public abstract Product factoryMethod();
}public class ConcreteCreator extends Creator {public Product factoryMethod() {return new ConcreteProduct();}
}

应用场景：

• JDBC 的 Connection 对象创建
• 日志框架中的 Appender 创建

3. 抽象工厂模式 (Abstract Factory)

目的：提供一个接口，用于创建相关或依赖对象的家族

public interface AbstractFactory {ProductA createProductA();ProductB createProductB();
}public class ConcreteFactory1 implements AbstractFactory {public ProductA createProductA() { return new ProductA1(); }public ProductB createProductB() { return new ProductB1(); }
}public class ConcreteFactory2 implements AbstractFactory {public ProductA createProductA() { return new ProductA2(); }public ProductB createProductB() { return new ProductB2(); }
}

应用场景：

• GUI 工具包
• 数据库访问层

4. 建造者模式 (Builder)

目的：将一个复杂对象的构建与其表示分离

public class Computer {private String CPU;private String RAM;public static class Builder {private String CPU;private String RAM;public Builder setCPU(String CPU) {this.CPU = CPU;return this;}public Builder setRAM(String RAM) {this.RAM = RAM;return this;}public Computer build() {Computer computer = new Computer();computer.CPU = this.CPU;computer.RAM = this.RAM;return computer;}}
}

应用场景：

• 创建复杂对象
• 多个构造参数且可选时

5. 原型模式 (Prototype)

目的：通过复制现有对象来创建新对象

public abstract class Prototype implements Cloneable {public Prototype clone() throws CloneNotSupportedException {return (Prototype)super.clone();}
}public class ConcretePrototype extends Prototype {private String field;public ConcretePrototype(String field) {this.field = field;}public void setField(String field) {this.field = field;}public String getField() {return field;}
}

应用场景：

• 创建对象成本较高时
• 需要保存对象状态

三、结构型模式 (7种)

1. 适配器模式 (Adapter)

目的：将一个类的接口转换成客户希望的另一个接口

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

应用场景：

• 使用第三方库时接口不匹配
• 旧系统改造

2. 桥接模式 (Bridge)

目的：将抽象部分与实现部分分离

public interface Implementor {void operationImpl();
}public class ConcreteImplementorA implements Implementor {public void operationImpl() {System.out.println("Implementation A");}
}public abstract class Abstraction {protected Implementor implementor;public Abstraction(Implementor implementor) {this.implementor = implementor;}public abstract void operation();
}public class RefinedAbstraction extends Abstraction {public RefinedAbstraction(Implementor implementor) {super(implementor);}public void operation() {implementor.operationImpl();}
}

应用场景：

• GUI 开发
• 驱动程序

3. 组合模式 (Composite)

目的：表示"部分-整体"的层次结构

public interface Component {void operation();void add(Component c);void remove(Component c);Component getChild(int i);
}public class Leaf implements Component {public void operation() {System.out.println("Leaf operation");}public void add(Component c) {throw new UnsupportedOperationException();}public void remove(Component c) {throw new UnsupportedOperationException();}public Component getChild(int i) {throw new UnsupportedOperationException();}
}public class Composite implements Component {private List<Component> children = new ArrayList<>();public void operation() {for (Component child : children) {child.operation();}}public void add(Component c) {children.add(c);}public void remove(Component c) {children.remove(c);}public Component getChild(int i) {return children.get(i);}
}

应用场景：

• 文件系统
• GUI 组件树

4. 装饰器模式 (Decorator)

目的：动态添加职责

public interface Component {void operation();
}public class ConcreteComponent implements Component {public void operation() {System.out.println("Basic operation");}
}public abstract class Decorator implements Component {protected Component component;public Decorator(Component component) {this.component = component;}public void operation() {component.operation();}
}public class ConcreteDecoratorA extends Decorator {public ConcreteDecoratorA(Component component) {super(component);}public void operation() {super.operation();addedBehavior();}private void addedBehavior() {System.out.println("Added behavior A");}
}

应用场景：

• Java I/O 流
• 动态添加功能

5. 外观模式 (Facade)

目的：为子系统提供统一接口

public class SubsystemA {public void operationA() {System.out.println("Subsystem A operation");}
}public class SubsystemB {public void operationB() {System.out.println("Subsystem B operation");}
}public class Facade {private SubsystemA a;private SubsystemB b;public Facade() {a = new SubsystemA();b = new SubsystemB();}public void operation() {a.operationA();b.operationB();}
}

应用场景：

• 简化复杂系统
• 分层设计

6. 享元模式 (Flyweight)

目的：支持大量细粒度对象

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

应用场景：

• 文本编辑器
• 游戏对象

7. 代理模式 (Proxy)

目的：控制对象访问

public interface Subject {void request();
}public class RealSubject implements Subject {public void request() {System.out.println("Real subject request");}
}public class Proxy implements Subject {private RealSubject realSubject;public void request() {if (realSubject == null) {realSubject = new RealSubject();}preRequest();realSubject.request();postRequest();}private void preRequest() {System.out.println("Pre request");}private void postRequest() {System.out.println("Post request");}
}

代理类型：

• 远程代理
• 虚拟代理
• 保护代理

应用场景：

• Spring AOP
• Hibernate 延迟加载

四、行为型模式 (11种)

1. 责任链模式 (Chain of Responsibility)

目的：使多个对象都有机会处理请求

public abstract class Handler {protected Handler successor;public void setSuccessor(Handler successor) {this.successor = successor;}public abstract void handleRequest(Request request);
}public class ConcreteHandlerA extends Handler {public void handleRequest(Request request) {if (canHandle(request)) {System.out.println("Handled by A");} else if (successor != null) {successor.handleRequest(request);}}private boolean canHandle(Request request) {return request.getType().equals("A");}
}

应用场景：

• 异常处理
• 审批流程

2. 命令模式 (Command)

目的：将请求封装为对象

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

应用场景：

• 事务系统
• 撤销功能

3. 解释器模式 (Interpreter)

目的：定义语言的文法表示

public interface Expression {boolean interpret(String context);
}public class TerminalExpression implements Expression {private String data;public TerminalExpression(String data) {this.data = data;}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;}public boolean interpret(String context) {return expr1.interpret(context) || expr2.interpret(context);}
}

应用场景：

• 正则表达式
• SQL 解析

4. 迭代器模式 (Iterator)

目的：顺序访问聚合对象元素

public interface Iterator<T> {boolean hasNext();T next();
}public interface Aggregate<T> {Iterator<T> createIterator();
}public class ConcreteAggregate<T> implements Aggregate<T> {private List<T> items = new ArrayList<>();public Iterator<T> createIterator() {return new ConcreteIterator<T>(this);}public int size() {return items.size();}public T get(int index) {return items.get(index);}public void add(T item) {items.add(item);}
}public class ConcreteIterator<T> implements Iterator<T> {private ConcreteAggregate<T> aggregate;private int index = 0;public ConcreteIterator(ConcreteAggregate<T> aggregate) {this.aggregate = aggregate;}public boolean hasNext() {return index < aggregate.size();}public T next() {if (hasNext()) {return aggregate.get(index++);}throw new NoSuchElementException();}
}

应用场景：

• 集合框架
• 树形遍历

5. 中介者模式 (Mediator)

目的：封装对象交互

public abstract class Colleague {protected Mediator mediator;public Colleague(Mediator mediator) {this.mediator = mediator;}
}public class ConcreteColleagueA extends Colleague {public ConcreteColleagueA(Mediator mediator) {super(mediator);}public void send(String message) {mediator.send(message, this);}public void receive(String message) {System.out.println("ColleagueA received: " + message);}
}public interface Mediator {void send(String message, Colleague colleague);
}public class ConcreteMediator implements Mediator {private ConcreteColleagueA colleagueA;private ConcreteColleagueB colleagueB;public void setColleagueA(ConcreteColleagueA colleagueA) {this.colleagueA = colleagueA;}public void setColleagueB(ConcreteColleagueB colleagueB) {this.colleagueB = colleagueB;}public void send(String message, Colleague colleague) {if (colleague == colleagueA) {colleagueB.receive(message);} else {colleagueA.receive(message);}}
}

应用场景：

• GUI 通信
• 聊天室

6. 备忘录模式 (Memento)

目的：捕获对象状态

public class Originator {private String state;public void setState(String state) {this.state = state;}public String getState() {return state;}public Memento saveStateToMemento() {return new Memento(state);}public void getStateFromMemento(Memento memento) {state = memento.getState();}
}public class Memento {private String state;public Memento(String state) {this.state = state;}public String getState() {return state;}
}public 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);}
}

应用场景：

• 撤销功能
• 游戏存档

7. 观察者模式 (Observer)

目的：一对多依赖关系

public interface Subject {void registerObserver(Observer o);void removeObserver(Observer o);void notifyObservers();
}public class ConcreteSubject implements Subject {private List<Observer> observers = new ArrayList<>();private int state;public int getState() {return state;}public void setState(int state) {this.state = state;notifyObservers();}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();}}
}public interface Observer {void update();
}public class ConcreteObserver implements Observer {private ConcreteSubject subject;public ConcreteObserver(ConcreteSubject subject) {this.subject = subject;subject.registerObserver(this);}public void update() {System.out.println("State changed to: " + subject.getState());}
}

应用场景：

• 事件处理
• MVC

8. 状态模式 (State)

目的：根据状态改变行为

public interface State {void handle(Context context);
}public class ConcreteStateA implements State {public void handle(Context context) {System.out.println("Handling in State A");context.setState(new ConcreteStateB());}
}public class ConcreteStateB implements State {public void handle(Context context) {System.out.println("Handling in State B");context.setState(new ConcreteStateA());}
}public class Context {private State state;public Context(State state) {this.state = state;}public void setState(State state) {this.state = state;}public void request() {state.handle(this);}
}

应用场景：

• 工作流引擎
• 订单状态

9. 策略模式 (Strategy)

目的：封装可替换算法

public interface Strategy {int doOperation(int num1, int num2);
}public class OperationAdd implements Strategy {public int doOperation(int num1, int num2) {return num1 + num2;}
}public class OperationSubtract implements Strategy {public int doOperation(int num1, int num2) {return num1 - num2;}
}public class Context {private Strategy strategy;public Context(Strategy strategy) {this.strategy = strategy;}public int executeStrategy(int num1, int num2) {return strategy.doOperation(num1, num2);}
}

应用场景：

• 支付方式
• 排序算法

10. 模板方法模式 (Template Method)

目的：定义算法骨架

public abstract class Game {abstract void initialize();abstract void startPlay();abstract void endPlay();public final void play() {initialize();startPlay();endPlay();}
}public class Cricket extends Game {void initialize() {System.out.println("Cricket Game Initialized");}void startPlay() {System.out.println("Cricket Game Started");}void endPlay() {System.out.println("Cricket Game Finished");}
}public class Football extends Game {void initialize() {System.out.println("Football Game Initialized");}void startPlay() {System.out.println("Football Game Started");}void endPlay() {System.out.println("Football Game Finished");}
}

应用场景：

• 框架设计
• JUnit

11. 访问者模式 (Visitor)

目的：不改变元素类的前提下定义新操作

public interface ComputerPart {void accept(ComputerPartVisitor visitor);
}public class Keyboard implements ComputerPart {public void accept(ComputerPartVisitor visitor) {visitor.visit(this);}
}public interface ComputerPartVisitor {void visit(Computer computer);void visit(Mouse mouse);void visit(Keyboard keyboard);void visit(Monitor monitor);
}public class ComputerPartDisplayVisitor implements ComputerPartVisitor {public void visit(Computer computer) {System.out.println("Displaying Computer");}public void visit(Mouse mouse) {System.out.println("Displaying Mouse");}public void visit(Keyboard keyboard) {System.out.println("Displaying Keyboard");}public void visit(Monitor monitor) {System.out.println("Displaying Monitor");}
}

应用场景：

• 编译器分析
• XML处理

五、设计模式的基本原则

1. SOLID 原则

SOLID 是面向对象设计的五个基本原则：

1. 单一职责原则 (SRP)

   • 一个类应该只有一个引起变化的原因
   • 示例：将数据持久化和业务逻辑分离到不同类

2. 开闭原则 (OCP)

   • 软件实体应对扩展开放，对修改关闭
   • 示例：使用策略模式实现不同的算法扩展

3. 里氏替换原则 (LSP)

   • 子类必须能够替换它们的基类
   • 示例：正方形不应继承长方形（因为修改边长行为不同）

4. 接口隔离原则 (ISP)

   • 客户端不应被迫依赖它们不使用的接口
   • 示例：将大型接口拆分为多个专用接口

5. 依赖倒置原则 (DIP)

   • 高层模块不应依赖低层模块，二者都应依赖抽象
   • 示例：通过依赖注入实现松耦合

2. DRY 原则

• Don’t Repeat Yourself（不要重复自己）
• 通过抽象消除重复代码
• 示例：将通用功能提取到基类或工具类中

3. KISS 原则

• Keep It Simple, Stupid（保持简单）
• 避免不必要的复杂性
• 示例：优先使用简单if-else而非策略模式（当逻辑简单时）

4. YAGNI 原则

• You Aren’t Gonna Need It（你不会需要它）
• 不要实现当前不需要的功能
• 示例：避免过早优化或过度设计

5. LoD（迪米特法则）

• 最少知识原则
• 一个对象应当对其他对象有尽可能少的了解
• 示例：通过外观模式封装子系统交互

六、设计模式的关系与对比

1. 相似模式对比

模式对比	关键区别
策略模式 vs 状态模式	策略是主动选择，状态是自动转换
装饰器模式 vs 代理模式	装饰器增强功能，代理控制访问
命令模式 vs 策略模式	命令封装动作和参数，策略封装算法

2. 模式组合应用

• 工厂方法 + 原型模式：通过克隆创建对象
• 组合模式 + 访问者模式：遍历复杂结构并执行操作
• 观察者模式 + 中介者模式：协调多个对象间的通信

七、设计模式在现代框架中的应用

1. Spring 框架中的模式

• 依赖注入：组合了工厂模式和策略模式
• AOP：代理模式的典型实现
• Bean作用域：单例和原型模式的应用

2. Java EE 中的模式

• Servlet Filter：责任链模式
• JMS：观察者模式的实现
• EJB：外观模式和代理模式的结合

八、设计模式的反模式

1. 常见反模式

• 上帝对象：违反单一职责原则
• 贫血模型：将行为和数据分离的错误实践
• 循环依赖：破坏模块化设计

2. 过度使用模式的危害

• 可读性下降：简单问题复杂化
• 维护成本增加：不必要的抽象层
• 性能损耗：过多的间接调用

九、设计模式的选择与使用原则

1. 如何选择设计模式

1. 明确问题：首先清楚你要解决什么问题
2. 分析模式：了解各种模式的意图和适用场景
3. 评估方案：考虑模式带来的复杂性和收益
4. 保持简单：不要为了使用模式而使用模式

2. 设计模式的最佳实践

• 理解原则而非死记硬背：理解SOLID原则比记住23种模式更重要
• 适度使用：过度设计比设计不足更糟糕
• 结合具体场景：没有放之四海皆准的模式
• 重构到模式：先写出可工作的代码，再通过重构引入模式

3. 常见误区

• 认为设计模式是银弹，能解决所有问题
• 在不必要时使用复杂模式
• 生搬硬套，不考虑实际场景
• 忽视模式带来的复杂性

十、总结

Java设计模式是面向对象设计经验的总结，合理使用可以提高代码的：

• 可维护性
• 可扩展性
• 重用性

关键原则：

• 理解设计原则和适用场景 > 死记硬背实现代码
• 根据具体问题选择合适模式
• 避免过度设计