ava 开发中最常用的七大设计模式：场景解析与代码实现
设计模式是软件开发中经过验证的最佳实践，合理运用设计模式可以提升代码的可维护性、可扩展性和可读性。本文将结合实际场景，详细介绍 Java 开发中最常用的七大设计模式，并附带有注释的代码示例。
一、单例模式（Singleton Pattern）
模式定义：确保一个类只有一个实例，并提供全局访问点。
适用场景：
全局唯一的资源管理（如线程池、缓存、日志对象）。
需要节省内存资源的场景（仅创建一个实例）。
实现方式：枚举单例（线程安全、抗反射攻击）
typescript 体验AI代码助手 代码解读复制代码/**
枚举单例（推荐）
优点：线程安全，防止反射攻击，代码简洁
*/
public enum Singleton {
INSTANCE; // 唯一实例
// 示例方法：模拟获取配置
public String getConfig() {
return “config from singleton”;
}
}
// 使用示例
public class Client {
public static void main(String[] args) {
Singleton instance1 = Singleton.INSTANCE;
Singleton instance2 = Singleton.INSTANCE;
System.out.println(instance1 == instance2); // 输出 true
}
}
二、工厂模式（Factory Pattern）
模式定义：通过工厂类封装对象的创建逻辑，客户端无需知道具体实现类。
适用场景：
对象创建逻辑复杂（如参数校验、初始化步骤）。
需要解耦对象创建和使用的场景。
实现方式：简单工厂（创建不同日志处理器）
typescript 体验AI代码助手 代码解读复制代码// 日志接口
interface Logger {
void log(String message);
}
// 控制台日志实现
class ConsoleLogger implements Logger {
@Override
public void log(String message) {
System.out.println("Console: " + message);
}
}
// 文件日志实现
class FileLogger implements Logger {
@Override
public void log(String message) {
System.out.println("File: " + message);
}
}
// 工厂类
class LoggerFactory {
// 根据类型创建日志对象
public static Logger createLogger(String type) {
if (“console”.equalsIgnoreCase(type)) {
return new ConsoleLogger();
} else if (“file”.equalsIgnoreCase(type)) {
return new FileLogger();
} else {
throw new IllegalArgumentException("Unsupported logger type: " + type);
}
}
}
// 使用示例
public class Client {
public static void main(String[] args) {
Logger consoleLogger = LoggerFactory.createLogger(“console”);
consoleLogger.log(“Hello, World!”); // 输出：Console: Hello, World!
}
}
三、策略模式（Strategy Pattern）
模式定义：定义一系列算法，将每个算法封装起来，使其可以相互替换。
适用场景：
算法动态切换（如支付方式、排序策略）。
避免多重条件判断（将条件逻辑封装为策略类）。
实现方式：支付策略（支付宝 / 微信支付）
java
java 体验AI代码助手 代码解读复制代码// 支付策略接口
interface PaymentStrategy {
void pay(double amount);
}
// 支付宝支付策略
class AlipayStrategy implements PaymentStrategy {
@Override
public void pay(double amount) {
System.out.println(“使用支付宝支付：” + amount + “元”);
}
}
// 微信支付策略
class WechatPayStrategy implements PaymentStrategy {
@Override
public void pay(double amount) {
System.out.println(“使用微信支付：” + amount + “元”);
}
}
// 上下文类（管理策略）
class PaymentContext {
private PaymentStrategy strategy;
public PaymentContext(PaymentStrategy strategy) {
this.strategy = strategy;
}
public void setStrategy(PaymentStrategy strategy) {
this.strategy = strategy;
}
public void executePayment(double amount) {
strategy.pay(amount);
}
}
// 使用示例
public class Client {
public static void main(String[] args) {
PaymentContext context = new PaymentContext(new AlipayStrategy());
context.executePayment(199.9); // 输出：使用支付宝支付：199.9元
context.setStrategy(new WechatPayStrategy());
context.executePayment(88.8); // 输出：使用微信支付：88.8元
}
}
四、观察者模式（Observer Pattern）
模式定义：定义对象间的一种一对多依赖关系，当一个对象状态改变时，其依赖的对象都能得到通知并自动更新。
适用场景：
消息订阅与发布（如事件总线、通知系统）。
监听状态变化（如股票价格变动、天气预警）。
实现方式：天气观察者（观察者订阅天气更新）
java 体验AI代码助手 代码解读复制代码// 主题接口（被观察者）
interface WeatherSubject {
void addObserver(WeatherObserver observer); // 添加观察者
void removeObserver(WeatherObserver observer); // 移除观察者
void notifyObservers(); // 通知所有观察者
void setTemperature(double temperature); // 更新温度
}
// 观察者接口
interface WeatherObserver {
void update(double temperature); // 接收更新通知
}
// 具体主题（天气数据中心）
class WeatherDataCenter implements WeatherSubject {
private double temperature;
private final List observers = new ArrayList<>();
@Override
public void addObserver(WeatherObserver observer) {
observers.add(observer);
}
@Override
public void removeObserver(WeatherObserver observer) {
observers.remove(observer);
}
@Override
public void notifyObservers() {
for (WeatherObserver observer : observers) {
observer.update(temperature); // 推送更新
}
}
@Override
public void setTemperature(double temperature) {
this.temperature = temperature;
notifyObservers(); // 温度变化时主动通知
}
}
// 具体观察者（手机APP）
class MobileAppObserver implements WeatherObserver {
private final String name;
public MobileAppObserver(String name) {
this.name = name;
}
@Override
public void update(double temperature) {
System.out.println(name + " 收到通知：当前温度为 " + temperature + "℃");
}
}
// 使用示例
public class Client {
public static void main(String[] args) {
WeatherDataCenter subject = new WeatherDataCenter();
WeatherObserver app1 = new MobileAppObserver(“天气通”);
WeatherObserver app2 = new MobileAppObserver(“彩云天气”);
subject.addObserver(app1);
subject.addObserver(app2);
subject.setTemperature(25.5); // 温度变化，触发通知
// 输出：
// 天气通 收到通知：当前温度为 25.5℃
// 彩云天气 收到通知：当前温度为 25.5℃
}
}
五、装饰器模式（Decorator Pattern）
模式定义：动态地给一个对象添加额外的职责，比继承更灵活。
适用场景：
扩展对象功能（如 IO 流的缓冲、加密装饰）。
避免通过继承导致类爆炸（多层继承）。
实现方式：咖啡调味（基础咖啡 + 牛奶 / 糖浆装饰）
java 体验AI代码助手 代码解读复制代码// 饮料接口
interface Beverage {
String getDescription(); // 获取描述
double cost(); // 计算价格
}
// 基础咖啡（具体组件）
class BasicCoffee implements Beverage {
@Override
public String getDescription() {
return “基础咖啡”;
}
@Override
public double cost() {
return 15.0; // 基础价格
}
}
// 装饰器抽象类（继承饮料接口，持有被装饰对象）
abstract class BeverageDecorator implements Beverage {
protected final Beverage beverage; // 被装饰的饮料
public BeverageDecorator(Beverage beverage) {
this.beverage = beverage;
}
@Override
public abstract String getDescription();
@Override
public abstract double cost();
}
// 牛奶装饰器（具体装饰器）
class MilkDecorator extends BeverageDecorator {
public MilkDecorator(Beverage beverage) {
super(beverage);
}
@Override
public String getDescription() {
return beverage.getDescription() + " + 牛奶"; // 扩展描述
}
@Override
public double cost() {
return beverage.cost() + 3.0; // 增加牛奶的价格
}
}
// 糖浆装饰器（具体装饰器）
class SyrupDecorator extends BeverageDecorator {
public SyrupDecorator(Beverage beverage) {
super(beverage);
}
@Override
public String getDescription() {
return beverage.getDescription() + " + 糖浆";
}
@Override
public double cost() {
return beverage.cost() + 2.0;
}
}
// 使用示例
public class Client {
public static void main(String[] args) {
// 基础咖啡 + 牛奶 + 糖浆
Beverage coffee = new BasicCoffee();
coffee = new MilkDecorator(coffee);
coffee = new SyrupDecorator(coffee);
System.out.println("饮料：" + coffee.getDescription());
System.out.println("价格：" + coffee.cost() + "元");
// 输出：
// 饮料：基础咖啡 + 牛奶 + 糖浆
// 价格：20.0元
}
}
六、适配器模式（Adapter Pattern）
模式定义：将一个类的接口转换成客户希望的另一个接口，使不兼容的接口可以协同工作。
适用场景：
兼容旧系统接口（如将第三方库接口转换为内部接口）。
类的接口与客户需求不匹配，但又不能修改原有类。
实现方式：电压适配器（220V 转 5V）
csharp 体验AI代码助手 代码解读复制代码// 目标接口（手机需要5V充电）
interface FiveVolt {
int getVolt5(); // 获取5V电压
}
// 被适配者（电源提供220V电压）
class AC220Volt {
public int getVolt220() {
return 220; // 原始电压
}
}
// 适配器类（将220V转换为5V）
class VoltageAdapter extends AC220Volt implements FiveVolt {
@Override
public int getVolt5() {
int volt220 = getVolt220();
// 模拟降压逻辑（实际需物理电路）
return volt220 / 44; // 220V -> 5V
}
}
// 使用示例
public class Client {
public static void main(String[] args) {
FiveVolt charger = new VoltageAdapter();
System.out.println(“手机充电电压：” + charger.getVolt5() + “V”); // 输出：5V
}
}
七、模板方法模式（Template Method Pattern）
模式定义：定义一个算法的骨架，将具体步骤延迟到子类实现，子类可以在不改变算法结构的情况下重新定义某些步骤。
适用场景：
多个子类有公共逻辑（如文件操作流程、审批流程）。
避免代码重复，统一算法骨架。
实现方式：文件处理器（读取文件 + 解析逻辑）
typescript 体验AI代码助手 代码解读复制代码// 模板类（定义文件处理流程）
abstract class FileProcessor {
// 模板方法：固定处理流程
public final void processFile(String path) {
String content = readFile(path); // 读取文件（子类实现）
parseContent(content); // 解析内容（子类实现）
saveToDatabase(content); // 保存到数据库（公共逻辑）
}
// 子类必须实现的抽象方法
protected abstract String readFile(String path);
protected abstract void parseContent(String content);
// 公共方法（子类可覆盖，默认实现）
protected void saveToDatabase(String content) {
System.out.println("保存内容到数据库：" + content);
}
}
// CSV文件处理器（具体子类）
class CSVProcessor extends FileProcessor {
@Override
protected String readFile(String path) {
return “模拟读取CSV文件内容：姓名,年龄\n张三,25”;
}
@Override
protected void parseContent(String content) {
System.out.println("解析CSV内容：" + content);
}
// 覆盖公共方法（可选）
@Override
protected void saveToDatabase(String content) {
System.out.println("特殊处理：将CSV内容存入专用表");
}
}
// 使用示例
public class Client {
public static void main(String[] args) {
FileProcessor processor = new CSVProcessor();
processor.processFile(“data.csv”);
// 输出：
// 解析CSV内容：姓名,年龄\n张三,25
// 特殊处理：将CSV内容存入专用表
}
}
总结：设计模式的核心思想
单一职责原则：每个类只负责单一功能（如工厂类只负责创建对象）。
开闭原则：对扩展开放，对修改关闭（如策略模式新增策略无需修改原有代码）。
组合复用原则：优先使用组合 / 聚合，而非继承（如装饰器模式通过持有对象实现功能扩展）。
作者：天天摸鱼的java工程师
链接：https://juejin.cn/post/7504175652771561511
来源：稀土掘金
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。