- 创建型模式:解决对象创建问题(如单例、工厂)
- 结构型模式:优化对象组合方式(如适配器、代理)
- 行为型模式:管理对象间协作(如观察者、策略)
一、创建型模式(5种)
- 单例模式(Singleton)
- 保证一个类仅有一个实例,并提供全局访问点。
- 典型应用:全局配置、线程池、数据库连接池。
/*** 饿汉式:类加载时初始化实例* ✅ 线程安全 | ❌ 非延迟加载 | ❌ 反射/序列化可能破坏单例*/public class EagerSingleton {// 类加载时直接创建实例(final 防止重新赋值)private static final EagerSingleton INSTANCE = new EagerSingleton();// 私有构造方法阻止外部实例化private EagerSingleton() {System.out.println("EagerSingleton instance created");}public static EagerSingleton getInstance() {return INSTANCE;}}/*** 基础懒汉式:延迟加载但线程不安全* ❌ 线程不安全 | ✅ 延迟加载 | ❌ 反射/序列化可能破坏单例*/public class LazySingleton {private static LazySingleton instance;private LazySingleton() {System.out.println("LazySingleton instance created");}public static LazySingleton getInstance() {if (instance == null) {instance = new LazySingleton(); // 多线程可能创建多个实例}return instance;}}/*** 同步懒汉式:通过 synchronized 保证线程安全* ✅ 线程安全 | ✅ 延迟加载 | ❌ 性能较低*/public class SyncLazySingleton {private static SyncLazySingleton instance;private SyncLazySingleton() {System.out.println("SyncLazySingleton instance created");}public static synchronized SyncLazySingleton getInstance() {if (instance == null) {instance = new SyncLazySingleton();}return instance;}}/*** 双重检查锁:线程安全且高性能* ✅ 线程安全 | ✅ 延迟加载 | ✅ 高性能*/public class DCLSingleton {// volatile 防止指令重排序(JDK5+)private static volatile DCLSingleton instance;private DCLSingleton() {System.out.println("DCLSingleton instance created");}public static DCLSingleton getInstance() {if (instance == null) { // 第一次检查(避免不必要的锁)synchronized (DCLSingleton.class) {if (instance == null) { // 第二次检查(防止重复创建)instance = new DCLSingleton();}}}return instance;}}/*** 静态内部类:利用类加载机制保证线程安全* ✅ 线程安全 | ✅ 延迟加载 | ✅ 无锁高性能*/public class HolderSingleton {private HolderSingleton() {System.out.println("HolderSingleton instance created");}// 静态内部类在首次调用 getInstance() 时加载private static class Holder {static final HolderSingleton INSTANCE = new HolderSingleton();}public static HolderSingleton getInstance() {return Holder.INSTANCE;}}/*** 枚举单例:Effective Java 推荐写法* ✅ 绝对线程安全 | ✅ 自动防反射/序列化攻击 | ❌ 无法继承其他类*/public enum EnumSingleton {INSTANCE;public void doSomething() {System.out.println("EnumSingleton instance method called");}}/** * 饿汉式:类加载时初始化实例 * ✅ 线程安全 | ❌ 非延迟加载 | ❌ 反射/序列化可能破坏单例 */ public class EagerSingleton { // 类加载时直接创建实例(final 防止重新赋值) private static final EagerSingleton INSTANCE = new EagerSingleton(); // 私有构造方法阻止外部实例化 private EagerSingleton() { System.out.println("EagerSingleton instance created"); } public static EagerSingleton getInstance() { return INSTANCE; } } /** * 基础懒汉式:延迟加载但线程不安全 * ❌ 线程不安全 | ✅ 延迟加载 | ❌ 反射/序列化可能破坏单例 */ public class LazySingleton { private static LazySingleton instance; private LazySingleton() { System.out.println("LazySingleton instance created"); } public static LazySingleton getInstance() { if (instance == null) { instance = new LazySingleton(); // 多线程可能创建多个实例 } return instance; } } /** * 同步懒汉式:通过 synchronized 保证线程安全 * ✅ 线程安全 | ✅ 延迟加载 | ❌ 性能较低 */ public class SyncLazySingleton { private static SyncLazySingleton instance; private SyncLazySingleton() { System.out.println("SyncLazySingleton instance created"); } public static synchronized SyncLazySingleton getInstance() { if (instance == null) { instance = new SyncLazySingleton(); } return instance; } } /** * 双重检查锁:线程安全且高性能 * ✅ 线程安全 | ✅ 延迟加载 | ✅ 高性能 */ public class DCLSingleton { // volatile 防止指令重排序(JDK5+) private static volatile DCLSingleton instance; private DCLSingleton() { System.out.println("DCLSingleton instance created"); } public static DCLSingleton getInstance() { if (instance == null) { // 第一次检查(避免不必要的锁) synchronized (DCLSingleton.class) { if (instance == null) { // 第二次检查(防止重复创建) instance = new DCLSingleton(); } } } return instance; } } /** * 静态内部类:利用类加载机制保证线程安全 * ✅ 线程安全 | ✅ 延迟加载 | ✅ 无锁高性能 */ public class HolderSingleton { private HolderSingleton() { System.out.println("HolderSingleton instance created"); } // 静态内部类在首次调用 getInstance() 时加载 private static class Holder { static final HolderSingleton INSTANCE = new HolderSingleton(); } public static HolderSingleton getInstance() { return Holder.INSTANCE; } } /** * 枚举单例:Effective Java 推荐写法 * ✅ 绝对线程安全 | ✅ 自动防反射/序列化攻击 | ❌ 无法继承其他类 */ public enum EnumSingleton { INSTANCE; public void doSomething() { System.out.println("EnumSingleton instance method called"); } }
- 工厂方法模式(Factory Method)
- 定义一个创建对象的接口,由子类决定实例化的具体类。
- 典型应用:动态创建对象,如日志记录器。
public class Client {public static void main(String[] args) {// 通过具体工厂创建产品AnimalFactory dogFactory = new DogFactory();Animal dog = dogFactory.createAnimal();dog.speak(); // 输出:汪汪!AnimalFactory catFactory = new CatFactory();Animal cat = catFactory.createAnimal();cat.speak(); // 输出:喵喵!}}// 1. 抽象产品(定义产品规范)interface Animal {void speak(); // 动物发声方法}// 2. 具体产品(实现具体功能)class Dog implements Animal {@Overridepublic void speak() {System.out.println("汪汪!");}}class Cat implements Animal {@Overridepublic void speak() {System.out.println("喵喵!");}}// 3. 抽象工厂(声明创建方法)interface AnimalFactory {Animal createAnimal(); // 工厂方法定义}// 4. 具体工厂(实现创建逻辑)class DogFactory implements AnimalFactory {@Overridepublic Animal createAnimal() {return new Dog(); // 生产狗对象}}class CatFactory implements AnimalFactory {@Overridepublic Animal createAnimal() {return new Cat(); // 生产猫对象}}=============================================class DynamicAnimalFactory implements AnimalFactory {private String type;public DynamicAnimalFactory(String type) {this.type = type;}@Overridepublic Animal createAnimal() {switch(type.toLowerCase()) {case "dog": return new Dog();case "cat": return new Cat();default: throw new IllegalArgumentException("未知动物类型");}}}// 使用示例AnimalFactory factory = new DynamicAnimalFactory("dog");Animal animal = factory.createAnimal();public class Client { public static void main(String[] args) { // 通过具体工厂创建产品 AnimalFactory dogFactory = new DogFactory(); Animal dog = dogFactory.createAnimal(); dog.speak(); // 输出:汪汪! AnimalFactory catFactory = new CatFactory(); Animal cat = catFactory.createAnimal(); cat.speak(); // 输出:喵喵! } } // 1. 抽象产品(定义产品规范) interface Animal { void speak(); // 动物发声方法 } // 2. 具体产品(实现具体功能) class Dog implements Animal { @Override public void speak() { System.out.println("汪汪!"); } } class Cat implements Animal { @Override public void speak() { System.out.println("喵喵!"); } } // 3. 抽象工厂(声明创建方法) interface AnimalFactory { Animal createAnimal(); // 工厂方法定义 } // 4. 具体工厂(实现创建逻辑) class DogFactory implements AnimalFactory { @Override public Animal createAnimal() { return new Dog(); // 生产狗对象 } } class CatFactory implements AnimalFactory { @Override public Animal createAnimal() { return new Cat(); // 生产猫对象 } } ============================================= class DynamicAnimalFactory implements AnimalFactory { private String type; public DynamicAnimalFactory(String type) { this.type = type; } @Override public Animal createAnimal() { switch(type.toLowerCase()) { case "dog": return new Dog(); case "cat": return new Cat(); default: throw new IllegalArgumentException("未知动物类型"); } } } // 使用示例 AnimalFactory factory = new DynamicAnimalFactory("dog"); Animal animal = factory.createAnimal();
- 抽象工厂模式(Abstract Factory)
- 创建相关或依赖对象的家族,而无需指定具体类。
- 典型应用:跨平台UI组件库(如不同操作系统的按钮和窗口)。
// ================== 抽象产品定义 ==================interface Button {void render();}interface Border {void draw();}// ================== 具体产品实现 ==================// Mac 系列产品class MacButton implements Button {@Overridepublic void render() {System.out.println("Mac 风格按钮:[🟢]");}}class MacBorder implements Border {@Overridepublic void draw() {System.out.println("Mac 风格边框:⎔⎔⎔⎔");}}// Win 系列产品class WinButton implements Button {@Overridepublic void render() {System.out.println("Windows 风格按钮:[■]");}}class WinBorder implements Border {@Overridepublic void draw() {System.out.println("Windows 风格边框:▦▦▦▦");}}// ================== 抽象工厂接口 ==================interface UIFactory {Button createButton();Border createBorder();}// ================== 具体工厂实现 ==================class MacUIFactory implements UIFactory {@Overridepublic Button createButton() {return new MacButton();}@Overridepublic Border createBorder() {return new MacBorder();}}class WinUIFactory implements UIFactory {@Overridepublic Button createButton() {return new WinButton();}@Overridepublic Border createBorder() {return new WinBorder();}}// ================== 客户端调用 ==================public class AbstractFactoryDemo {public static void main(String[] args) {// 根据配置动态选择工厂(可通过配置文件/环境变量控制)UIFactory factory = getOSFactory();// 通过抽象接口创建产品族Button button = factory.createButton();Border border = factory.createBorder();button.render(); // 输出:Mac/Windows 风格按钮border.draw(); // 输出:Mac/Windows 风格边框}// 模拟根据系统选择工厂private static UIFactory getOSFactory() {String os = System.getProperty("os.name").toLowerCase();if (os.contains("mac")) return new MacUIFactory();else return new WinUIFactory();}}=======================电脑硬件工厂(Intel/AMD 兼容组件)============================// ================== 抽象产品定义 ==================interface CPU {void process();}interface Motherboard {void installCPU(CPU cpu);}// ================== 具体产品实现 ==================// Intel 系列产品class IntelCPU implements CPU {@Overridepublic void process() {System.out.println("Intel Core i9 处理器运行中...");}}class IntelMotherboard implements Motherboard {@Overridepublic void installCPU(CPU cpu) {System.out.println("在 Intel 主板上安装:" + cpu.getClass().getSimpleName());}}// AMD 系列产品class AmdCPU implements CPU {@Overridepublic void process() {System.out.println("AMD Ryzen 9 处理器运行中...");}}class AmdMotherboard implements Motherboard {@Overridepublic void installCPU(CPU cpu) {System.out.println("在 AMD 主板上安装:" + cpu.getClass().getSimpleName());}}// ================== 抽象工厂接口 ==================interface ComputerFactory {CPU createCPU();Motherboard createMotherboard();}// ================== 具体工厂实现 ==================class IntelFactory implements ComputerFactory {@Overridepublic CPU createCPU() {return new IntelCPU();}@Overridepublic Motherboard createMotherboard() {return new IntelMotherboard();}}class AmdFactory implements ComputerFactory {@Overridepublic CPU createCPU() {return new AmdCPU();}@Overridepublic Motherboard createMotherboard() {return new AmdMotherboard();}}// ================== 客户端调用 ==================public class ComputerClient {public static void main(String[] args) {ComputerFactory factory = new IntelFactory(); // 更换为 AmdFactory 即可切换产品族CPU cpu = factory.createCPU();Motherboard mb = factory.createMotherboard();cpu.process(); // 输出处理器运行信息mb.installCPU(cpu); // 确保硬件兼容性}}// ================== 抽象产品定义 ================== interface Button { void render(); } interface Border { void draw(); } // ================== 具体产品实现 ================== // Mac 系列产品 class MacButton implements Button { @Override public void render() { System.out.println("Mac 风格按钮:[🟢]"); } } class MacBorder implements Border { @Override public void draw() { System.out.println("Mac 风格边框:⎔⎔⎔⎔"); } } // Win 系列产品 class WinButton implements Button { @Override public void render() { System.out.println("Windows 风格按钮:[■]"); } } class WinBorder implements Border { @Override public void draw() { System.out.println("Windows 风格边框:▦▦▦▦"); } } // ================== 抽象工厂接口 ================== interface UIFactory { Button createButton(); Border createBorder(); } // ================== 具体工厂实现 ================== class MacUIFactory implements UIFactory { @Override public Button createButton() { return new MacButton(); } @Override public Border createBorder() { return new MacBorder(); } } class WinUIFactory implements UIFactory { @Override public Button createButton() { return new WinButton(); } @Override public Border createBorder() { return new WinBorder(); } } // ================== 客户端调用 ================== public class AbstractFactoryDemo { public static void main(String[] args) { // 根据配置动态选择工厂(可通过配置文件/环境变量控制) UIFactory factory = getOSFactory(); // 通过抽象接口创建产品族 Button button = factory.createButton(); Border border = factory.createBorder(); button.render(); // 输出:Mac/Windows 风格按钮 border.draw(); // 输出:Mac/Windows 风格边框 } // 模拟根据系统选择工厂 private static UIFactory getOSFactory() { String os = System.getProperty("os.name").toLowerCase(); if (os.contains("mac")) return new MacUIFactory(); else return new WinUIFactory(); } } =======================电脑硬件工厂(Intel/AMD 兼容组件)============================ // ================== 抽象产品定义 ================== interface CPU { void process(); } interface Motherboard { void installCPU(CPU cpu); } // ================== 具体产品实现 ================== // Intel 系列产品 class IntelCPU implements CPU { @Override public void process() { System.out.println("Intel Core i9 处理器运行中..."); } } class IntelMotherboard implements Motherboard { @Override public void installCPU(CPU cpu) { System.out.println("在 Intel 主板上安装:" + cpu.getClass().getSimpleName()); } } // AMD 系列产品 class AmdCPU implements CPU { @Override public void process() { System.out.println("AMD Ryzen 9 处理器运行中..."); } } class AmdMotherboard implements Motherboard { @Override public void installCPU(CPU cpu) { System.out.println("在 AMD 主板上安装:" + cpu.getClass().getSimpleName()); } } // ================== 抽象工厂接口 ================== interface ComputerFactory { CPU createCPU(); Motherboard createMotherboard(); } // ================== 具体工厂实现 ================== class IntelFactory implements ComputerFactory { @Override public CPU createCPU() { return new IntelCPU(); } @Override public Motherboard createMotherboard() { return new IntelMotherboard(); } } class AmdFactory implements ComputerFactory { @Override public CPU createCPU() { return new AmdCPU(); } @Override public Motherboard createMotherboard() { return new AmdMotherboard(); } } // ================== 客户端调用 ================== public class ComputerClient { public static void main(String[] args) { ComputerFactory factory = new IntelFactory(); // 更换为 AmdFactory 即可切换产品族 CPU cpu = factory.createCPU(); Motherboard mb = factory.createMotherboard(); cpu.process(); // 输出处理器运行信息 mb.installCPU(cpu); // 确保硬件兼容性 } }
- 建造者模式(Builder)
- 分步构造复杂对象,允许灵活配置不同属性的组合。
- 典型应用:生成复杂表单、组装计算机配件。
/*** 产品类:电脑(包含多个可选参数)*/class Computer {// 必选参数private final String cpu;private final String ram;private final String storage;// 可选参数private final String gpu; // 显卡(可选)private final String power; // 电源(可选)/*** 私有构造方法,只能通过Builder创建实例* @param builder 建造者对象*/private Computer(Builder builder) {this.cpu = builder.cpu;this.ram = builder.ram;this.storage = builder.storage;this.gpu = builder.gpu;this.power = builder.power;}@Overridepublic String toString() {return "Computer{" +"cpu='" + cpu + '\'' +", ram='" + ram + '\'' +", storage='" + storage + '\'' +", gpu='" + (gpu != null ? gpu : "无独立显卡") + '\'' +", power='" + (power != null ? power : "默认电源") + '\'' +'}';}/*** 静态内部建造者类(核心实现)[1,3,6](@ref)*/public static class Builder {// 必选参数private final String cpu;private final String ram;private final String storage;// 可选参数(设置默认值)private String gpu = null;private String power = null;/*** 构造方法设置必选参数* @param cpu CPU型号* @param ram 内存容量* @param storage 存储容量*/public Builder(String cpu, String ram, String storage) {this.cpu = cpu;this.ram = ram;this.storage = storage;}/*** 设置可选参数:显卡(返回this支持链式调用)*/public Builder setGpu(String gpu) {this.gpu = gpu;return this;}/*** 设置可选参数:电源(返回this支持链式调用)*/public Builder setPower(String power) {this.power = power;return this;}/*** 最终构建方法*/public Computer build() {return new Computer(this);}}}// 客户端使用示例public class BuilderDemo {public static void main(String[] args) {// 构建游戏电脑(包含所有参数)Computer gamingPC = new Computer.Builder("Intel i9", "32GB", "2TB SSD").setGpu("RTX 4090").setPower("1000W Gold").build();// 构建办公电脑(使用默认可选参数)Computer officePC = new Computer.Builder("Intel i5", "16GB", "512GB SSD").build(); // 不设置可选参数System.out.println("游戏电脑:" + gamingPC);System.out.println("办公电脑:" + officePC);}}/** * 产品类:电脑(包含多个可选参数) */ class Computer { // 必选参数 private final String cpu; private final String ram; private final String storage; // 可选参数 private final String gpu; // 显卡(可选) private final String power; // 电源(可选) /** * 私有构造方法,只能通过Builder创建实例 * @param builder 建造者对象 */ private Computer(Builder builder) { this.cpu = builder.cpu; this.ram = builder.ram; this.storage = builder.storage; this.gpu = builder.gpu; this.power = builder.power; } @Override public String toString() { return "Computer{" + "cpu='" + cpu + '\'' + ", ram='" + ram + '\'' + ", storage='" + storage + '\'' + ", gpu='" + (gpu != null ? gpu : "无独立显卡") + '\'' + ", power='" + (power != null ? power : "默认电源") + '\'' + '}'; } /** * 静态内部建造者类(核心实现)[1,3,6](@ref) */ public static class Builder { // 必选参数 private final String cpu; private final String ram; private final String storage; // 可选参数(设置默认值) private String gpu = null; private String power = null; /** * 构造方法设置必选参数 * @param cpu CPU型号 * @param ram 内存容量 * @param storage 存储容量 */ public Builder(String cpu, String ram, String storage) { this.cpu = cpu; this.ram = ram; this.storage = storage; } /** * 设置可选参数:显卡(返回this支持链式调用) */ public Builder setGpu(String gpu) { this.gpu = gpu; return this; } /** * 设置可选参数:电源(返回this支持链式调用) */ public Builder setPower(String power) { this.power = power; return this; } /** * 最终构建方法 */ public Computer build() { return new Computer(this); } } } // 客户端使用示例 public class BuilderDemo { public static void main(String[] args) { // 构建游戏电脑(包含所有参数) Computer gamingPC = new Computer.Builder("Intel i9", "32GB", "2TB SSD") .setGpu("RTX 4090") .setPower("1000W Gold") .build(); // 构建办公电脑(使用默认可选参数) Computer officePC = new Computer.Builder("Intel i5", "16GB", "512GB SSD") .build(); // 不设置可选参数 System.out.println("游戏电脑:" + gamingPC); System.out.println("办公电脑:" + officePC); } }
- 原型模式(Prototype)
- 通过复制现有实例创建新对象,避免重复初始化。
- 典型应用:游戏中的角色克隆、批量生成相似对象。
import java.io.*;import java.util.ArrayList;import java.util.List;/*** 原型模式演示:计算机配置模板克隆* 包含浅拷贝和深拷贝两种实现方式*/class Computer implements Cloneable, Serializable {// 基础类型字段(浅拷贝可复制)private String cpu;private int memorySize;// 引用类型字段(需要深拷贝)private List<String> installedSoftware;public Computer(String cpu, int memorySize) {this.cpu = cpu;this.memorySize = memorySize;this.installedSoftware = new ArrayList<>();// 模拟耗时初始化(如读取数据库)initializeDefaultSoftware();}private void initializeDefaultSoftware() {installedSoftware.add("操作系统");installedSoftware.add("基础驱动");System.out.println(">>> 完成基础软件安装(耗时操作)");}//---------- 浅拷贝实现 ----------@Overridepublic Computer clone() {try {// 浅拷贝(基础类型正确复制,引用类型共享地址)return (Computer) super.clone();} catch (CloneNotSupportedException e) {throw new AssertionError(); // 不可能发生}}//---------- 深拷贝实现 ----------public Computer deepClone() {try {// 序列化方式实现深拷贝ByteArrayOutputStream bos = new ByteArrayOutputStream();ObjectOutputStream oos = new ObjectOutputStream(bos);oos.writeObject(this);ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());ObjectInputStream ois = new ObjectInputStream(bis);return (Computer) ois.readObject();} catch (IOException | ClassNotFoundException e) {throw new RuntimeException("深拷贝失败", e);}}//---------- 辅助方法 ----------public void installSoftware(String software) {installedSoftware.add(software);}@Overridepublic String toString() {return String.format("计算机[CPU:%s 内存:%dG 软件:%s]@%s",cpu, memorySize, installedSoftware, hashCode());}}/*** 客户端使用演示*/public class PrototypeDemo {public static void main(String[] args) {// 创建原型对象(耗时初始化)Computer prototype = new Computer("i7-12700", 32);prototype.installSoftware("开发工具");// 浅拷贝克隆Computer shallowCopy = prototype.clone();shallowCopy.installSoftware("办公软件");// 深拷贝克隆Computer deepCopy = prototype.deepClone();deepCopy.installSoftware("图形工具");// 结果比较System.out.println("\n原型对象:" + prototype);System.out.println("浅拷贝对象:" + shallowCopy);System.out.println("深拷贝对象:" + deepCopy);}}import java.io.*; import java.util.ArrayList; import java.util.List; /** * 原型模式演示:计算机配置模板克隆 * 包含浅拷贝和深拷贝两种实现方式 */ class Computer implements Cloneable, Serializable { // 基础类型字段(浅拷贝可复制) private String cpu; private int memorySize; // 引用类型字段(需要深拷贝) private List<String> installedSoftware; public Computer(String cpu, int memorySize) { this.cpu = cpu; this.memorySize = memorySize; this.installedSoftware = new ArrayList<>(); // 模拟耗时初始化(如读取数据库) initializeDefaultSoftware(); } private void initializeDefaultSoftware() { installedSoftware.add("操作系统"); installedSoftware.add("基础驱动"); System.out.println(">>> 完成基础软件安装(耗时操作)"); } //---------- 浅拷贝实现 ---------- @Override public Computer clone() { try { // 浅拷贝(基础类型正确复制,引用类型共享地址) return (Computer) super.clone(); } catch (CloneNotSupportedException e) { throw new AssertionError(); // 不可能发生 } } //---------- 深拷贝实现 ---------- public Computer deepClone() { try { // 序列化方式实现深拷贝 ByteArrayOutputStream bos = new ByteArrayOutputStream(); ObjectOutputStream oos = new ObjectOutputStream(bos); oos.writeObject(this); ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray()); ObjectInputStream ois = new ObjectInputStream(bis); return (Computer) ois.readObject(); } catch (IOException | ClassNotFoundException e) { throw new RuntimeException("深拷贝失败", e); } } //---------- 辅助方法 ---------- public void installSoftware(String software) { installedSoftware.add(software); } @Override public String toString() { return String.format("计算机[CPU:%s 内存:%dG 软件:%s]@%s", cpu, memorySize, installedSoftware, hashCode()); } } /** * 客户端使用演示 */ public class PrototypeDemo { public static void main(String[] args) { // 创建原型对象(耗时初始化) Computer prototype = new Computer("i7-12700", 32); prototype.installSoftware("开发工具"); // 浅拷贝克隆 Computer shallowCopy = prototype.clone(); shallowCopy.installSoftware("办公软件"); // 深拷贝克隆 Computer deepCopy = prototype.deepClone(); deepCopy.installSoftware("图形工具"); // 结果比较 System.out.println("\n原型对象:" + prototype); System.out.println("浅拷贝对象:" + shallowCopy); System.out.println("深拷贝对象:" + deepCopy); } }
二、结构型模式(7种)
- 适配器模式(Adapter)
- 转换接口使不兼容的类协同工作。
- 典型应用:兼容旧系统接口、第三方库集成。
// ================== 目标接口 ==================/*** 目标接口:Type-C充电接口(新标准)*/interface TypeCCharger {void chargeWithTypeC();}// ================== 被适配者 ==================/*** 被适配者:MicroUSB充电器(旧设备)*/class MicroUSBCharger {public void chargeWithMicroUSB() {System.out.println("正在使用MicroUSB接口充电...");}}// ================== 类适配器实现 ==================/*** 类适配器(通过继承实现)* 说明:适配器继承被适配者并实现目标接口*/class ClassAdapter extends MicroUSBCharger implements TypeCCharger {@Overridepublic void chargeWithTypeC() {System.out.println("[类适配器] 将Type-C信号转换为MicroUSB");super.chargeWithMicroUSB(); // 调用父类方法}}// ================== 对象适配器实现 ==================/*** 对象适配器(通过组合实现)* 说明:适配器持有被适配者实例并实现目标接口*/class ObjectAdapter implements TypeCCharger {private MicroUSBCharger microUSBCharger;public ObjectAdapter(MicroUSBCharger microUSBCharger) {this.microUSBCharger = microUSBCharger;}@Overridepublic void chargeWithTypeC() {System.out.println("[对象适配器] 转换Type-C到MicroUSB");microUSBCharger.chargeWithMicroUSB(); // 委托调用}}// ================== 客户端代码 ==================public class AdapterPatternDemo {public static void main(String[] args) {// 原始设备直接调用(旧接口)MicroUSBCharger oldCharger = new MicroUSBCharger();oldCharger.chargeWithMicroUSB();// ----------------------------// 类适配器调用TypeCCharger classAdapter = new ClassAdapter();classAdapter.chargeWithTypeC();// 对象适配器调用TypeCCharger objectAdapter = new ObjectAdapter(oldCharger);objectAdapter.chargeWithTypeC();}}// ================== 目标接口 ================== /** * 目标接口:Type-C充电接口(新标准) */ interface TypeCCharger { void chargeWithTypeC(); } // ================== 被适配者 ================== /** * 被适配者:MicroUSB充电器(旧设备) */ class MicroUSBCharger { public void chargeWithMicroUSB() { System.out.println("正在使用MicroUSB接口充电..."); } } // ================== 类适配器实现 ================== /** * 类适配器(通过继承实现) * 说明:适配器继承被适配者并实现目标接口 */ class ClassAdapter extends MicroUSBCharger implements TypeCCharger { @Override public void chargeWithTypeC() { System.out.println("[类适配器] 将Type-C信号转换为MicroUSB"); super.chargeWithMicroUSB(); // 调用父类方法 } } // ================== 对象适配器实现 ================== /** * 对象适配器(通过组合实现) * 说明:适配器持有被适配者实例并实现目标接口 */ class ObjectAdapter implements TypeCCharger { private MicroUSBCharger microUSBCharger; public ObjectAdapter(MicroUSBCharger microUSBCharger) { this.microUSBCharger = microUSBCharger; } @Override public void chargeWithTypeC() { System.out.println("[对象适配器] 转换Type-C到MicroUSB"); microUSBCharger.chargeWithMicroUSB(); // 委托调用 } } // ================== 客户端代码 ================== public class AdapterPatternDemo { public static void main(String[] args) { // 原始设备直接调用(旧接口) MicroUSBCharger oldCharger = new MicroUSBCharger(); oldCharger.chargeWithMicroUSB(); // ---------------------------- // 类适配器调用 TypeCCharger classAdapter = new ClassAdapter(); classAdapter.chargeWithTypeC(); // 对象适配器调用 TypeCCharger objectAdapter = new ObjectAdapter(oldCharger); objectAdapter.chargeWithTypeC(); } }
- 桥接模式(Bridge)
- 将抽象与实现解耦,使两者可独立变化。
- 典型应用:遥控器控制不同品牌电视。
// ================== 实现部分接口:颜色渲染 ==================/*** 颜色接口(实现部分)* 定义图形填充颜色的具体实现规范[6](@ref)*/interface Color {void applyColor();}/*** 红色实现类(具体实现部分)*/class RedColor implements Color {@Overridepublic void applyColor() {System.out.print("红色的");}}/*** 蓝色实现类(具体实现部分)*/class BlueColor implements Color {@Overridepublic void applyColor() {System.out.print("蓝色的");}}// ================== 抽象部分基类:形状定义 ==================/*** 形状抽象类(抽象部分)* 持有颜色接口的引用实现桥接[2,6](@ref)*/abstract class Shape {protected Color color; // 桥接关键点:组合实现部分public Shape(Color color) {this.color = color;}public abstract void draw();}/*** 圆形扩展类(扩展抽象部分)*/class Circle extends Shape {public Circle(Color color) {super(color);}@Overridepublic void draw() {System.out.print("绘制");color.applyColor(); // 委托颜色实现System.out.println("圆形");}}/*** 正方形扩展类(扩展抽象部分)*/class Square extends Shape {public Square(Color color) {super(color);}@Overridepublic void draw() {System.out.print("绘制");color.applyColor();System.out.println("正方形");}}// ================== 客户端调用 ==================public class BridgePatternDemo {public static void main(String[] args) {// 创建颜色实例(实现部分)Color red = new RedColor();Color blue = new BlueColor();// 桥接组合:形状+颜色(抽象+实现)Shape redCircle = new Circle(red);Shape blueSquare = new Square(blue);// 绘制图形redCircle.draw(); // 绘制红色的圆形blueSquare.draw(); // 绘制蓝色的正方形// 动态扩展新颜色无需修改形状类Shape greenCircle = new Circle(new GreenColor() {@Overridepublic void applyColor() {System.out.print("绿色的");}});greenCircle.draw(); // 绘制绿色的圆形}}// ================== 实现部分接口:颜色渲染 ================== /** * 颜色接口(实现部分) * 定义图形填充颜色的具体实现规范[6](@ref) */ interface Color { void applyColor(); } /** * 红色实现类(具体实现部分) */ class RedColor implements Color { @Override public void applyColor() { System.out.print("红色的"); } } /** * 蓝色实现类(具体实现部分) */ class BlueColor implements Color { @Override public void applyColor() { System.out.print("蓝色的"); } } // ================== 抽象部分基类:形状定义 ================== /** * 形状抽象类(抽象部分) * 持有颜色接口的引用实现桥接[2,6](@ref) */ abstract class Shape { protected Color color; // 桥接关键点:组合实现部分 public Shape(Color color) { this.color = color; } public abstract void draw(); } /** * 圆形扩展类(扩展抽象部分) */ class Circle extends Shape { public Circle(Color color) { super(color); } @Override public void draw() { System.out.print("绘制"); color.applyColor(); // 委托颜色实现 System.out.println("圆形"); } } /** * 正方形扩展类(扩展抽象部分) */ class Square extends Shape { public Square(Color color) { super(color); } @Override public void draw() { System.out.print("绘制"); color.applyColor(); System.out.println("正方形"); } } // ================== 客户端调用 ================== public class BridgePatternDemo { public static void main(String[] args) { // 创建颜色实例(实现部分) Color red = new RedColor(); Color blue = new BlueColor(); // 桥接组合:形状+颜色(抽象+实现) Shape redCircle = new Circle(red); Shape blueSquare = new Square(blue); // 绘制图形 redCircle.draw(); // 绘制红色的圆形 blueSquare.draw(); // 绘制蓝色的正方形 // 动态扩展新颜色无需修改形状类 Shape greenCircle = new Circle(new GreenColor() { @Override public void applyColor() { System.out.print("绿色的"); } }); greenCircle.draw(); // 绘制绿色的圆形 } }
- 组合模式(Composite)
- 将对象组合成树形结构以表示“部分-整体”关系。
- 典型应用:文件系统目录结构、组织架构管理。
/*** 组件抽象类(Component)* 定义文件系统元素的通用接口(文件/目录共用方法)* [3,5](@ref)*/abstract class FileSystemComponent {protected String name;public FileSystemComponent(String name) {this.name = name;}// 公共操作方法(文件/目录均支持)public abstract void display(int depth);// 容器管理方法(默认抛出异常,叶子节点需重写)public void add(FileSystemComponent component) {throw new UnsupportedOperationException();}public void remove(FileSystemComponent component) {throw new UnsupportedOperationException();}public FileSystemComponent getChild(int index) {throw new UnsupportedOperationException();}}/*** 叶子节点类(Leaf)- 文件* 实现具体元素的操作方法[8](@ref)*/class File extends FileSystemComponent {public File(String name) {super(name);}@Overridepublic void display(int depth) {System.out.println("-".repeat(depth) + "📄 " + name);}}/*** 组合节点类(Composite)- 目录* 包含子元素集合并实现容器管理方法[3,6](@ref)*/class Directory extends FileSystemComponent {private List<FileSystemComponent> children = new ArrayList<>();public Directory(String name) {super(name);}@Overridepublic void add(FileSystemComponent component) {children.add(component);}@Overridepublic void remove(FileSystemComponent component) {children.remove(component);}@Overridepublic FileSystemComponent getChild(int index) {return children.get(index);}@Overridepublic void display(int depth) {System.out.println("-".repeat(depth) + "📁 " + name);// 递归显示子元素[1](@ref)for (FileSystemComponent child : children) {child.display(depth + 2);}}}/*** 客户端测试类[5](@ref)*/public class CompositeDemo {public static void main(String[] args) {// 创建文件系统结构Directory root = new Directory("我的文档");Directory musicDir = new Directory("音乐");musicDir.add(new File("古典音乐.mp3"));musicDir.add(new File("流行歌曲.mp3"));Directory docDir = new Directory("工作文档");docDir.add(new File("需求文档.docx"));// 构建树形结构root.add(musicDir);root.add(docDir);root.add(new File("readme.txt"));// 显示完整结构(统一操作接口)[8](@ref)root.display(0);}}/** * 组件抽象类(Component) * 定义文件系统元素的通用接口(文件/目录共用方法) * [3,5](@ref) */ abstract class FileSystemComponent { protected String name; public FileSystemComponent(String name) { this.name = name; } // 公共操作方法(文件/目录均支持) public abstract void display(int depth); // 容器管理方法(默认抛出异常,叶子节点需重写) public void add(FileSystemComponent component) { throw new UnsupportedOperationException(); } public void remove(FileSystemComponent component) { throw new UnsupportedOperationException(); } public FileSystemComponent getChild(int index) { throw new UnsupportedOperationException(); } } /** * 叶子节点类(Leaf)- 文件 * 实现具体元素的操作方法[8](@ref) */ class File extends FileSystemComponent { public File(String name) { super(name); } @Override public void display(int depth) { System.out.println("-".repeat(depth) + "📄 " + name); } } /** * 组合节点类(Composite)- 目录 * 包含子元素集合并实现容器管理方法[3,6](@ref) */ class Directory extends FileSystemComponent { private List<FileSystemComponent> children = new ArrayList<>(); public Directory(String name) { super(name); } @Override public void add(FileSystemComponent component) { children.add(component); } @Override public void remove(FileSystemComponent component) { children.remove(component); } @Override public FileSystemComponent getChild(int index) { return children.get(index); } @Override public void display(int depth) { System.out.println("-".repeat(depth) + "📁 " + name); // 递归显示子元素[1](@ref) for (FileSystemComponent child : children) { child.display(depth + 2); } } } /** * 客户端测试类[5](@ref) */ public class CompositeDemo { public static void main(String[] args) { // 创建文件系统结构 Directory root = new Directory("我的文档"); Directory musicDir = new Directory("音乐"); musicDir.add(new File("古典音乐.mp3")); musicDir.add(new File("流行歌曲.mp3")); Directory docDir = new Directory("工作文档"); docDir.add(new File("需求文档.docx")); // 构建树形结构 root.add(musicDir); root.add(docDir); root.add(new File("readme.txt")); // 显示完整结构(统一操作接口)[8](@ref) root.display(0); } }
- 装饰器模式(Decorator)
- 动态添加功能,通过包装对象扩展行为。
- 典型应用:Java IO流(如BufferedInputStream)。
// 1. 定义抽象组件接口(核心功能规范)interface Coffee {String getDescription(); // 获取咖啡描述double cost(); // 计算价格}// 2. 具体组件实现(基础对象)class SimpleCoffee implements Coffee {@Overridepublic String getDescription() {return "基础咖啡";}@Overridepublic double cost() {return 12.0; // 基础价格12元}}// 3. 抽象装饰器(实现接口并持有组件引用)abstract class CoffeeDecorator implements Coffee {protected Coffee decoratedCoffee; // 被装饰对象public CoffeeDecorator(Coffee coffee) {this.decoratedCoffee = coffee;}// 默认直接调用被装饰对象的方法public String getDescription() {return decoratedCoffee.getDescription();}public double cost() {return decoratedCoffee.cost();}}// 4. 具体装饰器A(添加牛奶)class MilkDecorator extends CoffeeDecorator {public MilkDecorator(Coffee coffee) {super(coffee);}@Overridepublic String getDescription() {return super.getDescription() + " + 牛奶";}@Overridepublic double cost() {return super.cost() + 3.5; // 增加3.5元}}// 5. 具体装饰器B(添加焦糖)class CaramelDecorator extends CoffeeDecorator {public CaramelDecorator(Coffee coffee) {super(coffee);}@Overridepublic String getDescription() {return super.getDescription() + " + 焦糖";}@Overridepublic double cost() {return super.cost() + 5.0; // 增加5元}}// 客户端使用示例public class DecoratorDemo {public static void main(String[] args) {// 基础咖啡Coffee coffee = new SimpleCoffee();System.out.println(coffee.getDescription() + " 价格:" + coffee.cost());// 添加牛奶coffee = new MilkDecorator(coffee);System.out.println(coffee.getDescription() + " 价格:" + coffee.cost());// 再添加焦糖(装饰器可叠加)coffee = new CaramelDecorator(coffee);System.out.println(coffee.getDescription() + " 价格:" + coffee.cost());}}// 1. 定义抽象组件接口(核心功能规范) interface Coffee { String getDescription(); // 获取咖啡描述 double cost(); // 计算价格 } // 2. 具体组件实现(基础对象) class SimpleCoffee implements Coffee { @Override public String getDescription() { return "基础咖啡"; } @Override public double cost() { return 12.0; // 基础价格12元 } } // 3. 抽象装饰器(实现接口并持有组件引用) abstract class CoffeeDecorator implements Coffee { protected Coffee decoratedCoffee; // 被装饰对象 public CoffeeDecorator(Coffee coffee) { this.decoratedCoffee = coffee; } // 默认直接调用被装饰对象的方法 public String getDescription() { return decoratedCoffee.getDescription(); } public double cost() { return decoratedCoffee.cost(); } } // 4. 具体装饰器A(添加牛奶) class MilkDecorator extends CoffeeDecorator { public MilkDecorator(Coffee coffee) { super(coffee); } @Override public String getDescription() { return super.getDescription() + " + 牛奶"; } @Override public double cost() { return super.cost() + 3.5; // 增加3.5元 } } // 5. 具体装饰器B(添加焦糖) class CaramelDecorator extends CoffeeDecorator { public CaramelDecorator(Coffee coffee) { super(coffee); } @Override public String getDescription() { return super.getDescription() + " + 焦糖"; } @Override public double cost() { return super.cost() + 5.0; // 增加5元 } } // 客户端使用示例 public class DecoratorDemo { public static void main(String[] args) { // 基础咖啡 Coffee coffee = new SimpleCoffee(); System.out.println(coffee.getDescription() + " 价格:" + coffee.cost()); // 添加牛奶 coffee = new MilkDecorator(coffee); System.out.println(coffee.getDescription() + " 价格:" + coffee.cost()); // 再添加焦糖(装饰器可叠加) coffee = new CaramelDecorator(coffee); System.out.println(coffee.getDescription() + " 价格:" + coffee.cost()); } }
- 外观模式(Facade)
- 为复杂子系统提供简化接口。
- 典型应用:一键启动智能家居场景。
// 1. 定义子系统组件(家庭影院设备)class DVDPlayer {private static final DVDPlayer instance = new DVDPlayer();private DVDPlayer() {} // 私有构造public static DVDPlayer getInstance() {return instance;}public void on() {System.out.println("DVD播放器启动");}public void play(String movie) {System.out.println("播放电影:" + movie);}public void off() {System.out.println("DVD播放器关闭");}}class Projector {private static final Projector instance = new Projector();private Projector() {}public static Projector getInstance() {return instance;}public void on() {System.out.println("投影仪启动");}public void setInput(String source) {System.out.println("投影输入源切换至:" + source);}public void off() {System.out.println("投影仪关闭");}}class SoundSystem {private static final SoundSystem instance = new SoundSystem();private SoundSystem() {}public static SoundSystem getInstance() {return instance;}public void on() {System.out.println("音响系统启动");}public void setVolume(int level) {System.out.println("音量设置为:" + level);}public void off() {System.out.println("音响系统关闭");}}// 2. 外观类(家庭影院控制中心)class HomeTheaterFacade {private DVDPlayer dvdPlayer;private Projector projector;private SoundSystem soundSystem;public HomeTheaterFacade() {this.dvdPlayer = DVDPlayer.getInstance();this.projector = Projector.getInstance();this.soundSystem = SoundSystem.getInstance();}/*** 一键观影模式* @param movie 电影名称*/public void startMovie(String movie) {System.out.println("\n=== 启动家庭影院 ===");dvdPlayer.on();projector.on();projector.setInput("DVD");soundSystem.on();soundSystem.setVolume(60);dvdPlayer.play(movie);}/*** 一键关闭所有设备*/public void endMovie() {System.out.println("\n=== 关闭家庭影院 ===");dvdPlayer.off();projector.off();soundSystem.off();}}// 3. 客户端调用public class FacadeDemo {public static void main(String[] args) {HomeTheaterFacade theater = new HomeTheaterFacade();// 通过外观类简化操作theater.startMovie("阿凡达:水之道");theater.endMovie();}}// 1. 定义子系统组件(家庭影院设备) class DVDPlayer { private static final DVDPlayer instance = new DVDPlayer(); private DVDPlayer() {} // 私有构造 public static DVDPlayer getInstance() { return instance; } public void on() { System.out.println("DVD播放器启动"); } public void play(String movie) { System.out.println("播放电影:" + movie); } public void off() { System.out.println("DVD播放器关闭"); } } class Projector { private static final Projector instance = new Projector(); private Projector() {} public static Projector getInstance() { return instance; } public void on() { System.out.println("投影仪启动"); } public void setInput(String source) { System.out.println("投影输入源切换至:" + source); } public void off() { System.out.println("投影仪关闭"); } } class SoundSystem { private static final SoundSystem instance = new SoundSystem(); private SoundSystem() {} public static SoundSystem getInstance() { return instance; } public void on() { System.out.println("音响系统启动"); } public void setVolume(int level) { System.out.println("音量设置为:" + level); } public void off() { System.out.println("音响系统关闭"); } } // 2. 外观类(家庭影院控制中心) class HomeTheaterFacade { private DVDPlayer dvdPlayer; private Projector projector; private SoundSystem soundSystem; public HomeTheaterFacade() { this.dvdPlayer = DVDPlayer.getInstance(); this.projector = Projector.getInstance(); this.soundSystem = SoundSystem.getInstance(); } /** * 一键观影模式 * @param movie 电影名称 */ public void startMovie(String movie) { System.out.println("\n=== 启动家庭影院 ==="); dvdPlayer.on(); projector.on(); projector.setInput("DVD"); soundSystem.on(); soundSystem.setVolume(60); dvdPlayer.play(movie); } /** * 一键关闭所有设备 */ public void endMovie() { System.out.println("\n=== 关闭家庭影院 ==="); dvdPlayer.off(); projector.off(); soundSystem.off(); } } // 3. 客户端调用 public class FacadeDemo { public static void main(String[] args) { HomeTheaterFacade theater = new HomeTheaterFacade(); // 通过外观类简化操作 theater.startMovie("阿凡达:水之道"); theater.endMovie(); } }
- 享元模式(Flyweight)
- 通过共享技术高效支持大量细粒度对象。
- 典型应用:文本编辑器中的字符重复使用。
import java.util.HashMap;import java.util.Map;/*** 抽象享元接口 - 定义棋子操作规范*/interface ChessPiece {// 显示棋子,外部状态通过参数传递(坐标)void display(int x, int y);}/*** 具体享元类 - 实现棋子共享部分(内部状态:颜色)*/class ConcreteChessPiece implements ChessPiece {private final String color; // 内部状态(共享)public ConcreteChessPiece(String color) {this.color = color;}@Overridepublic void display(int x, int y) {System.out.printf("%s棋子位于坐标(%d,%d)\n", color, x, y);}}/*** 享元工厂类 - 管理棋子对象池*/class ChessPieceFactory {private static final Map<String, ChessPiece> pieces = new HashMap<>();// 获取棋子实例(线程不安全,多线程需加锁)public static ChessPiece getChessPiece(String color) {if (!pieces.containsKey(color)) {System.out.println("创建新棋子:" + color);pieces.put(color, new ConcreteChessPiece(color));}return pieces.get(color);}// 查询当前棋子种类数量public static int getPieceTypes() {return pieces.size();}}/*** 客户端演示*/public class FlyweightDemo {public static void main(String[] args) {// 模拟棋盘落子坐标(外部状态)int[][] positions = {{0,0}, {1,2}, {3,1}, {2,4}, {4,3}};// 获取棋子实例(颜色为内部状态)ChessPiece black1 = ChessPieceFactory.getChessPiece("黑");ChessPiece black2 = ChessPieceFactory.getChessPiece("黑");ChessPiece white1 = ChessPieceFactory.getChessPiece("白");ChessPiece white2 = ChessPieceFactory.getChessPiece("白");// 显示棋子位置black1.display(positions[0][0], positions[0][1]);black2.display(positions[1][0], positions[1][1]);white1.display(positions[2][0], positions[2][1]);white2.display(positions[3][0], positions[3][1]);// 验证对象复用System.out.println("总棋子种类:" + ChessPieceFactory.getPieceTypes());}}import java.util.HashMap; import java.util.Map; /** * 抽象享元接口 - 定义棋子操作规范 */ interface ChessPiece { // 显示棋子,外部状态通过参数传递(坐标) void display(int x, int y); } /** * 具体享元类 - 实现棋子共享部分(内部状态:颜色) */ class ConcreteChessPiece implements ChessPiece { private final String color; // 内部状态(共享) public ConcreteChessPiece(String color) { this.color = color; } @Override public void display(int x, int y) { System.out.printf("%s棋子位于坐标(%d,%d)\n", color, x, y); } } /** * 享元工厂类 - 管理棋子对象池 */ class ChessPieceFactory { private static final Map<String, ChessPiece> pieces = new HashMap<>(); // 获取棋子实例(线程不安全,多线程需加锁) public static ChessPiece getChessPiece(String color) { if (!pieces.containsKey(color)) { System.out.println("创建新棋子:" + color); pieces.put(color, new ConcreteChessPiece(color)); } return pieces.get(color); } // 查询当前棋子种类数量 public static int getPieceTypes() { return pieces.size(); } } /** * 客户端演示 */ public class FlyweightDemo { public static void main(String[] args) { // 模拟棋盘落子坐标(外部状态) int[][] positions = { {0,0}, {1,2}, {3,1}, {2,4}, {4,3} }; // 获取棋子实例(颜色为内部状态) ChessPiece black1 = ChessPieceFactory.getChessPiece("黑"); ChessPiece black2 = ChessPieceFactory.getChessPiece("黑"); ChessPiece white1 = ChessPieceFactory.getChessPiece("白"); ChessPiece white2 = ChessPieceFactory.getChessPiece("白"); // 显示棋子位置 black1.display(positions[0][0], positions[0][1]); black2.display(positions[1][0], positions[1][1]); white1.display(positions[2][0], positions[2][1]); white2.display(positions[3][0], positions[3][1]); // 验证对象复用 System.out.println("总棋子种类:" + ChessPieceFactory.getPieceTypes()); } }
- 代理模式(Proxy)
- 控制对象访问,提供间接层。
- 典型应用:远程调用、缓存代理、权限控制。
静态代理
// 1. 抽象接口(租房行为)interface Rent {void rent();}// 2. 真实对象(房东)class Landlord implements Rent {@Overridepublic void rent() {System.out.println("房东出租房子");}}// 3. 静态代理类(房产中介)class RentProxy implements Rent {private Landlord landlord; // 持有真实对象引用public RentProxy(Landlord landlord) {this.landlord = landlord;}@Overridepublic void rent() {preProcess(); // 前置增强landlord.rent(); // 调用真实对象方法postProcess(); // 后置增强}// 代理类自定义逻辑private void preProcess() {System.out.println("【静态代理】中介带客户看房");}private void postProcess() {System.out.println("【静态代理】中介签订合同");}}// 4. 客户端调用public class StaticProxyDemo {public static void main(String[] args) {Landlord landlord = new Landlord();RentProxy proxy = new RentProxy(landlord);proxy.rent(); // 通过代理访问}}=================JDK动态代理==========================import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;import java.lang.reflect.Proxy;// 1. 抽象接口(用户服务)interface UserService {void addUser(String name);}// 2. 真实对象(用户服务实现)class UserServiceImpl implements UserService {@Overridepublic void addUser(String name) {System.out.println("新增用户:" + name);}}// 3. 动态代理处理器(通用增强逻辑)class LoggingHandler implements InvocationHandler {private Object target; // 被代理对象public LoggingHandler(Object target) {this.target = target;}@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {System.out.println("【JDK动态代理】方法调用前记录日志");Object result = method.invoke(target, args); // 反射调用真实方法System.out.println("【JDK动态代理】方法调用后记录日志");return result;}}// 4. 客户端调用public class JdkDynamicProxyDemo {public static void main(String[] args) {UserService realService = new UserServiceImpl();// 动态生成代理对象UserService proxy = (UserService) Proxy.newProxyInstance(realService.getClass().getClassLoader(),realService.getClass().getInterfaces(),new LoggingHandler(realService));proxy.addUser("张三");}}===============CGLIB动态代理================import net.sf.cglib.proxy.Enhancer;import net.sf.cglib.proxy.MethodInterceptor;import net.sf.cglib.proxy.MethodProxy;// 1. 真实对象(无需接口)class PaymentService {public void pay() {System.out.println("完成支付");}}// 2. CGLIB代理拦截器class CglibProxyInterceptor implements MethodInterceptor {@Overridepublic Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {System.out.println("【CGLIB代理】支付前验证权限");Object result = proxy.invokeSuper(obj, args); // 调用父类方法System.out.println("【CGLIB代理】支付后记录流水");return result;}}// 3. 客户端调用public class CglibProxyDemo {public static void main(String[] args) {Enhancer enhancer = new Enhancer();enhancer.setSuperclass(PaymentService.class); // 设置父类enhancer.setCallback(new CglibProxyInterceptor());PaymentService proxy = (PaymentService) enhancer.create();proxy.pay();}}// 1. 抽象接口(租房行为) interface Rent { void rent(); } // 2. 真实对象(房东) class Landlord implements Rent { @Override public void rent() { System.out.println("房东出租房子"); } } // 3. 静态代理类(房产中介) class RentProxy implements Rent { private Landlord landlord; // 持有真实对象引用 public RentProxy(Landlord landlord) { this.landlord = landlord; } @Override public void rent() { preProcess(); // 前置增强 landlord.rent(); // 调用真实对象方法 postProcess(); // 后置增强 } // 代理类自定义逻辑 private void preProcess() { System.out.println("【静态代理】中介带客户看房"); } private void postProcess() { System.out.println("【静态代理】中介签订合同"); } } // 4. 客户端调用 public class StaticProxyDemo { public static void main(String[] args) { Landlord landlord = new Landlord(); RentProxy proxy = new RentProxy(landlord); proxy.rent(); // 通过代理访问 } } =================JDK动态代理========================== import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; // 1. 抽象接口(用户服务) interface UserService { void addUser(String name); } // 2. 真实对象(用户服务实现) class UserServiceImpl implements UserService { @Override public void addUser(String name) { System.out.println("新增用户:" + name); } } // 3. 动态代理处理器(通用增强逻辑) class LoggingHandler implements InvocationHandler { private Object target; // 被代理对象 public LoggingHandler(Object target) { this.target = target; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("【JDK动态代理】方法调用前记录日志"); Object result = method.invoke(target, args); // 反射调用真实方法 System.out.println("【JDK动态代理】方法调用后记录日志"); return result; } } // 4. 客户端调用 public class JdkDynamicProxyDemo { public static void main(String[] args) { UserService realService = new UserServiceImpl(); // 动态生成代理对象 UserService proxy = (UserService) Proxy.newProxyInstance( realService.getClass().getClassLoader(), realService.getClass().getInterfaces(), new LoggingHandler(realService) ); proxy.addUser("张三"); } } ===============CGLIB动态代理================ import net.sf.cglib.proxy.Enhancer; import net.sf.cglib.proxy.MethodInterceptor; import net.sf.cglib.proxy.MethodProxy; // 1. 真实对象(无需接口) class PaymentService { public void pay() { System.out.println("完成支付"); } } // 2. CGLIB代理拦截器 class CglibProxyInterceptor implements MethodInterceptor { @Override public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable { System.out.println("【CGLIB代理】支付前验证权限"); Object result = proxy.invokeSuper(obj, args); // 调用父类方法 System.out.println("【CGLIB代理】支付后记录流水"); return result; } } // 3. 客户端调用 public class CglibProxyDemo { public static void main(String[] args) { Enhancer enhancer = new Enhancer(); enhancer.setSuperclass(PaymentService.class); // 设置父类 enhancer.setCallback(new CglibProxyInterceptor()); PaymentService proxy = (PaymentService) enhancer.create(); proxy.pay(); } }
三、行为型模式(11种)
- 观察者模式(Observer)
- 定义一对多依赖关系,当主题状态变化时通知观察者。
- 典型应用:事件通知系统(如消息订阅)。
import java.util.ArrayList;import java.util.List;// 1. 抽象观察者接口(定义订阅者的通知接口)[1,4](@ref)interface Observer {void update(String message); // 接收通知的核心方法}// 2. 具体观察者类(微信用户)class WeChatUser implements Observer {private String username;public WeChatUser(String username) {this.username = username;}@Overridepublic void update(String message) {System.out.println(username + " 收到公众号推送:" + message);}}// 3. 抽象主题接口(定义公众号的管理接口)[1,7](@ref)interface Subject {void subscribe(Observer user); // 添加订阅者void unsubscribe(Observer user); // 移除订阅者void notifyUsers(String message); // 通知订阅者}// 4. 具体主题类(微信公众号)class WeChatOfficialAccount implements Subject {private List<Observer> subscribers = new ArrayList<>(); // 存储订阅者列表@Overridepublic void subscribe(Observer user) {subscribers.add(user);System.out.println(user + " 订阅成功");}@Overridepublic void unsubscribe(Observer user) {subscribers.remove(user);System.out.println(user + " 取消订阅");}@Overridepublic void notifyUsers(String message) {// 遍历所有订阅者并发送通知[3](@ref)for (Observer user : subscribers) {user.update(message);}}// 公众号发布新内容时触发通知public void publishArticle(String title) {System.out.println("\n公众号发布新文章:《" + title + "》");notifyUsers(title);}}// 5. 客户端测试public class ObserverPatternDemo {public static void main(String[] args) {// 创建公众号(被观察者)WeChatOfficialAccount account = new WeChatOfficialAccount();// 创建用户(观察者)Observer userA = new WeChatUser("张三");Observer userB = new WeChatUser("李四");Observer userC = new WeChatUser("王五");// 订阅公众号account.subscribe(userA);account.subscribe(userB);account.subscribe(userC);// 公众号发布文章(触发通知)account.publishArticle("Java设计模式精讲");// 用户取消订阅account.unsubscribe(userB);// 再次发布文章(仅通知剩余用户)account.publishArticle("Spring框架实战指南");}}import java.util.ArrayList; import java.util.List; // 1. 抽象观察者接口(定义订阅者的通知接口)[1,4](@ref) interface Observer { void update(String message); // 接收通知的核心方法 } // 2. 具体观察者类(微信用户) class WeChatUser implements Observer { private String username; public WeChatUser(String username) { this.username = username; } @Override public void update(String message) { System.out.println(username + " 收到公众号推送:" + message); } } // 3. 抽象主题接口(定义公众号的管理接口)[1,7](@ref) interface Subject { void subscribe(Observer user); // 添加订阅者 void unsubscribe(Observer user); // 移除订阅者 void notifyUsers(String message); // 通知订阅者 } // 4. 具体主题类(微信公众号) class WeChatOfficialAccount implements Subject { private List<Observer> subscribers = new ArrayList<>(); // 存储订阅者列表 @Override public void subscribe(Observer user) { subscribers.add(user); System.out.println(user + " 订阅成功"); } @Override public void unsubscribe(Observer user) { subscribers.remove(user); System.out.println(user + " 取消订阅"); } @Override public void notifyUsers(String message) { // 遍历所有订阅者并发送通知[3](@ref) for (Observer user : subscribers) { user.update(message); } } // 公众号发布新内容时触发通知 public void publishArticle(String title) { System.out.println("\n公众号发布新文章:《" + title + "》"); notifyUsers(title); } } // 5. 客户端测试 public class ObserverPatternDemo { public static void main(String[] args) { // 创建公众号(被观察者) WeChatOfficialAccount account = new WeChatOfficialAccount(); // 创建用户(观察者) Observer userA = new WeChatUser("张三"); Observer userB = new WeChatUser("李四"); Observer userC = new WeChatUser("王五"); // 订阅公众号 account.subscribe(userA); account.subscribe(userB); account.subscribe(userC); // 公众号发布文章(触发通知) account.publishArticle("Java设计模式精讲"); // 用户取消订阅 account.unsubscribe(userB); // 再次发布文章(仅通知剩余用户) account.publishArticle("Spring框架实战指南"); } }
- 策略模式(Strategy)
- 定义算法族并封装,使其可互相替换。
- 典型应用:支付方式选择、导航路线策略。
import java.math.BigDecimal;// 1. 策略接口:定义所有折扣策略的公共契约interface DiscountStrategy {BigDecimal applyDiscount(BigDecimal originalPrice);}// 2. 具体策略类:无折扣策略class NoDiscount implements DiscountStrategy {@Overridepublic BigDecimal applyDiscount(BigDecimal originalPrice) {return originalPrice;}}// 3. 具体策略类:百分比折扣(如8折)class PercentageDiscount implements DiscountStrategy {private final double percentage; // 折扣率(如0.2代表20%折扣)public PercentageDiscount(double percentage) {this.percentage = percentage;}@Overridepublic BigDecimal applyDiscount(BigDecimal originalPrice) {return originalPrice.multiply(BigDecimal.valueOf(1 - percentage));}}// 4. 具体策略类:满减折扣(如满100减30)class CashbackDiscount implements DiscountStrategy {private final BigDecimal cashbackAmount; // 满减金额public CashbackDiscount(BigDecimal cashbackAmount) {this.cashbackAmount = cashbackAmount;}@Overridepublic BigDecimal applyDiscount(BigDecimal originalPrice) {return originalPrice.subtract(cashbackAmount).max(BigDecimal.ZERO); // 确保金额不小于0}}// 5. 上下文类:购物车(持有策略对象并调用)class ShoppingCart {private DiscountStrategy strategy; // 当前使用的策略private BigDecimal total = BigDecimal.ZERO;public void setStrategy(DiscountStrategy strategy) {this.strategy = strategy;}public void addItem(BigDecimal price) {total = total.add(price);}public BigDecimal checkout() {return strategy.applyDiscount(total);}}// 6. 客户端调用public class StrategyDemo {public static void main(String[] args) {ShoppingCart cart = new ShoppingCart();cart.addItem(new BigDecimal("150.00"));// 动态切换策略cart.setStrategy(new NoDiscount());System.out.println("无折扣价格: " + cart.checkout());cart.setStrategy(new PercentageDiscount(0.2));System.out.println("8折价格: " + cart.checkout());cart.setStrategy(new CashbackDiscount(new BigDecimal("30")));System.out.println("满150减30价格: " + cart.checkout());}}import java.math.BigDecimal; // 1. 策略接口:定义所有折扣策略的公共契约 interface DiscountStrategy { BigDecimal applyDiscount(BigDecimal originalPrice); } // 2. 具体策略类:无折扣策略 class NoDiscount implements DiscountStrategy { @Override public BigDecimal applyDiscount(BigDecimal originalPrice) { return originalPrice; } } // 3. 具体策略类:百分比折扣(如8折) class PercentageDiscount implements DiscountStrategy { private final double percentage; // 折扣率(如0.2代表20%折扣) public PercentageDiscount(double percentage) { this.percentage = percentage; } @Override public BigDecimal applyDiscount(BigDecimal originalPrice) { return originalPrice.multiply(BigDecimal.valueOf(1 - percentage)); } } // 4. 具体策略类:满减折扣(如满100减30) class CashbackDiscount implements DiscountStrategy { private final BigDecimal cashbackAmount; // 满减金额 public CashbackDiscount(BigDecimal cashbackAmount) { this.cashbackAmount = cashbackAmount; } @Override public BigDecimal applyDiscount(BigDecimal originalPrice) { return originalPrice.subtract(cashbackAmount).max(BigDecimal.ZERO); // 确保金额不小于0 } } // 5. 上下文类:购物车(持有策略对象并调用) class ShoppingCart { private DiscountStrategy strategy; // 当前使用的策略 private BigDecimal total = BigDecimal.ZERO; public void setStrategy(DiscountStrategy strategy) { this.strategy = strategy; } public void addItem(BigDecimal price) { total = total.add(price); } public BigDecimal checkout() { return strategy.applyDiscount(total); } } // 6. 客户端调用 public class StrategyDemo { public static void main(String[] args) { ShoppingCart cart = new ShoppingCart(); cart.addItem(new BigDecimal("150.00")); // 动态切换策略 cart.setStrategy(new NoDiscount()); System.out.println("无折扣价格: " + cart.checkout()); cart.setStrategy(new PercentageDiscount(0.2)); System.out.println("8折价格: " + cart.checkout()); cart.setStrategy(new CashbackDiscount(new BigDecimal("30"))); System.out.println("满150减30价格: " + cart.checkout()); } }
- 命令模式(Command)
- 将请求封装为对象,支持撤销、重做和队列操作。
- 典型应用:任务队列、GUI操作回滚。
import java.util.ArrayList;import java.util.List;// 1. 命令接口:定义执行和撤销操作的标准interface Command {void execute(); // 执行命令void undo(); // 撤销命令}// 2. 接收者:实际执行命令的对象(灯)class Light {public void turnOn() {System.out.println("灯已打开");}public void turnOff() {System.out.println("灯已关闭");}}// 3. 具体命令类:开灯命令class LightOnCommand implements Command {private Light light; // 持有接收者对象public LightOnCommand(Light light) {this.light = light;}@Overridepublic void execute() {light.turnOn();}@Overridepublic void undo() {light.turnOff(); // 撤销操作即关灯}}// 4. 具体命令类:关灯命令class LightOffCommand implements Command {private Light light;public LightOffCommand(Light light) {this.light = light;}@Overridepublic void execute() {light.turnOff();}@Overridepublic void undo() {light.turnOn(); // 撤销操作即开灯}}// 5. 宏命令(组合多个命令)class MacroCommand implements Command {private List<Command> commands = new ArrayList<>();public void addCommand(Command command) {commands.add(command);}@Overridepublic void execute() {for (Command cmd : commands) {cmd.execute(); // 批量执行命令}}@Overridepublic void undo() {for (int i = commands.size() - 1; i >= 0; i--) {commands.get(i).undo(); // 逆序撤销命令}}}// 6. 调用者(遥控器)class RemoteControl {private Command command;public void setCommand(Command command) {this.command = command;}public void pressButton() {command.execute(); // 触发执行}public void pressUndo() {command.undo(); // 触发撤销}}// 7. 客户端测试public class CommandPatternDemo {public static void main(String[] args) {// 创建接收者(灯)Light livingRoomLight = new Light();// 创建具体命令Command lightOn = new LightOnCommand(livingRoomLight);Command lightOff = new LightOffCommand(livingRoomLight);// 创建宏命令(批量操作)MacroCommand partyMode = new MacroCommand();partyMode.addCommand(lightOn);partyMode.addCommand(lightOff);partyMode.addCommand(lightOn); // 组合多个命令// 调用者(遥控器)配置命令RemoteControl remote = new RemoteControl();remote.setCommand(lightOn);// 执行并撤销单个命令remote.pressButton(); // 输出:灯已打开remote.pressUndo(); // 输出:灯已关闭// 执行宏命令remote.setCommand(partyMode);remote.pressButton(); // 输出:灯已打开 → 灯已关闭 → 灯已打开remote.pressUndo(); // 输出:灯已关闭 → 灯已打开 → 灯已关闭}}import java.util.ArrayList; import java.util.List; // 1. 命令接口:定义执行和撤销操作的标准 interface Command { void execute(); // 执行命令 void undo(); // 撤销命令 } // 2. 接收者:实际执行命令的对象(灯) class Light { public void turnOn() { System.out.println("灯已打开"); } public void turnOff() { System.out.println("灯已关闭"); } } // 3. 具体命令类:开灯命令 class LightOnCommand implements Command { private Light light; // 持有接收者对象 public LightOnCommand(Light light) { this.light = light; } @Override public void execute() { light.turnOn(); } @Override public void undo() { light.turnOff(); // 撤销操作即关灯 } } // 4. 具体命令类:关灯命令 class LightOffCommand implements Command { private Light light; public LightOffCommand(Light light) { this.light = light; } @Override public void execute() { light.turnOff(); } @Override public void undo() { light.turnOn(); // 撤销操作即开灯 } } // 5. 宏命令(组合多个命令) class MacroCommand implements Command { private List<Command> commands = new ArrayList<>(); public void addCommand(Command command) { commands.add(command); } @Override public void execute() { for (Command cmd : commands) { cmd.execute(); // 批量执行命令 } } @Override public void undo() { for (int i = commands.size() - 1; i >= 0; i--) { commands.get(i).undo(); // 逆序撤销命令 } } } // 6. 调用者(遥控器) class RemoteControl { private Command command; public void setCommand(Command command) { this.command = command; } public void pressButton() { command.execute(); // 触发执行 } public void pressUndo() { command.undo(); // 触发撤销 } } // 7. 客户端测试 public class CommandPatternDemo { public static void main(String[] args) { // 创建接收者(灯) Light livingRoomLight = new Light(); // 创建具体命令 Command lightOn = new LightOnCommand(livingRoomLight); Command lightOff = new LightOffCommand(livingRoomLight); // 创建宏命令(批量操作) MacroCommand partyMode = new MacroCommand(); partyMode.addCommand(lightOn); partyMode.addCommand(lightOff); partyMode.addCommand(lightOn); // 组合多个命令 // 调用者(遥控器)配置命令 RemoteControl remote = new RemoteControl(); remote.setCommand(lightOn); // 执行并撤销单个命令 remote.pressButton(); // 输出:灯已打开 remote.pressUndo(); // 输出:灯已关闭 // 执行宏命令 remote.setCommand(partyMode); remote.pressButton(); // 输出:灯已打开 → 灯已关闭 → 灯已打开 remote.pressUndo(); // 输出:灯已关闭 → 灯已打开 → 灯已关闭 } }
- 状态模式(State)
- 允许对象在内部状态改变时改变行为。
- 典型应用:订单状态流转、游戏角色行为切换。
// 1. 状态接口:定义电梯所有可能的行为interface ElevatorState {void openDoor();void closeDoor();void run();void stop();}// 2. 具体状态类:开门状态class OpenState implements ElevatorState {private ElevatorContext context;public OpenState(ElevatorContext context) {this.context = context;}@Overridepublic void openDoor() {System.out.println("电梯门已经是打开状态,无需重复操作");}@Overridepublic void closeDoor() {System.out.println("电梯门关闭");context.setState(new CloseState(context)); // 切换为关门状态[4](@ref)}@Overridepublic void run() {System.out.println("错误:门未关闭,不能运行");}@Overridepublic void stop() {System.out.println("电梯已停止");}}// 3. 具体状态类:关门状态class CloseState implements ElevatorState {private ElevatorContext context;public CloseState(ElevatorContext context) {this.context = context;}@Overridepublic void openDoor() {System.out.println("电梯门打开");context.setState(new OpenState(context)); // 切换为开门状态}@Overridepublic void closeDoor() {System.out.println("电梯门已关闭,无需重复操作");}@Overridepublic void run() {System.out.println("电梯开始运行");context.setState(new RunState(context)); // 切换为运行状态[4](@ref)}@Overridepublic void stop() {System.out.println("电梯停止");context.setState(new StopState(context)); // 切换为停止状态}}// 4. 具体状态类:运行状态class RunState implements ElevatorState {private ElevatorContext context;public RunState(ElevatorContext context) {this.context = context;}@Overridepublic void openDoor() {System.out.println("错误:运行中禁止开门");}@Overridepublic void closeDoor() {System.out.println("电梯门已关闭,无需操作");}@Overridepublic void run() {System.out.println("电梯正在运行中");}@Overridepublic void stop() {System.out.println("电梯紧急停止");context.setState(new StopState(context));}}// 5. 具体状态类:停止状态class StopState implements ElevatorState {private ElevatorContext context;public StopState(ElevatorContext context) {this.context = context;}@Overridepublic void openDoor() {System.out.println("电梯门打开");context.setState(new OpenState(context));}@Overridepublic void closeDoor() {System.out.println("电梯门关闭");context.setState(new CloseState(context));}@Overridepublic void run() {System.out.println("电梯开始运行");context.setState(new RunState(context));}@Overridepublic void stop() {System.out.println("电梯已是停止状态");}}// 6. 上下文类(电梯控制器)class ElevatorContext {private ElevatorState currentState;public ElevatorContext() {currentState = new StopState(this); // 初始状态为停止}public void setState(ElevatorState state) {this.currentState = state;}// 委托当前状态处理操作public void openDoor() {currentState.openDoor();}public void closeDoor() {currentState.closeDoor();}public void run() {currentState.run();}public void stop() {currentState.stop();}}// 7. 客户端测试public class StatePatternDemo {public static void main(String[] args) {ElevatorContext elevator = new ElevatorContext();elevator.openDoor(); // 输出:电梯门打开(切换为开门状态)elevator.run(); // 输出:错误:门未关闭,不能运行elevator.closeDoor(); // 输出:电梯门关闭(切换为关门状态)elevator.run(); // 输出:电梯开始运行(切换为运行状态)elevator.openDoor(); // 输出:错误:运行中禁止开门elevator.stop(); // 输出:电梯紧急停止(切换为停止状态)}}// 1. 状态接口:定义电梯所有可能的行为 interface ElevatorState { void openDoor(); void closeDoor(); void run(); void stop(); } // 2. 具体状态类:开门状态 class OpenState implements ElevatorState { private ElevatorContext context; public OpenState(ElevatorContext context) { this.context = context; } @Override public void openDoor() { System.out.println("电梯门已经是打开状态,无需重复操作"); } @Override public void closeDoor() { System.out.println("电梯门关闭"); context.setState(new CloseState(context)); // 切换为关门状态[4](@ref) } @Override public void run() { System.out.println("错误:门未关闭,不能运行"); } @Override public void stop() { System.out.println("电梯已停止"); } } // 3. 具体状态类:关门状态 class CloseState implements ElevatorState { private ElevatorContext context; public CloseState(ElevatorContext context) { this.context = context; } @Override public void openDoor() { System.out.println("电梯门打开"); context.setState(new OpenState(context)); // 切换为开门状态 } @Override public void closeDoor() { System.out.println("电梯门已关闭,无需重复操作"); } @Override public void run() { System.out.println("电梯开始运行"); context.setState(new RunState(context)); // 切换为运行状态[4](@ref) } @Override public void stop() { System.out.println("电梯停止"); context.setState(new StopState(context)); // 切换为停止状态 } } // 4. 具体状态类:运行状态 class RunState implements ElevatorState { private ElevatorContext context; public RunState(ElevatorContext context) { this.context = context; } @Override public void openDoor() { System.out.println("错误:运行中禁止开门"); } @Override public void closeDoor() { System.out.println("电梯门已关闭,无需操作"); } @Override public void run() { System.out.println("电梯正在运行中"); } @Override public void stop() { System.out.println("电梯紧急停止"); context.setState(new StopState(context)); } } // 5. 具体状态类:停止状态 class StopState implements ElevatorState { private ElevatorContext context; public StopState(ElevatorContext context) { this.context = context; } @Override public void openDoor() { System.out.println("电梯门打开"); context.setState(new OpenState(context)); } @Override public void closeDoor() { System.out.println("电梯门关闭"); context.setState(new CloseState(context)); } @Override public void run() { System.out.println("电梯开始运行"); context.setState(new RunState(context)); } @Override public void stop() { System.out.println("电梯已是停止状态"); } } // 6. 上下文类(电梯控制器) class ElevatorContext { private ElevatorState currentState; public ElevatorContext() { currentState = new StopState(this); // 初始状态为停止 } public void setState(ElevatorState state) { this.currentState = state; } // 委托当前状态处理操作 public void openDoor() { currentState.openDoor(); } public void closeDoor() { currentState.closeDoor(); } public void run() { currentState.run(); } public void stop() { currentState.stop(); } } // 7. 客户端测试 public class StatePatternDemo { public static void main(String[] args) { ElevatorContext elevator = new ElevatorContext(); elevator.openDoor(); // 输出:电梯门打开(切换为开门状态) elevator.run(); // 输出:错误:门未关闭,不能运行 elevator.closeDoor(); // 输出:电梯门关闭(切换为关门状态) elevator.run(); // 输出:电梯开始运行(切换为运行状态) elevator.openDoor(); // 输出:错误:运行中禁止开门 elevator.stop(); // 输出:电梯紧急停止(切换为停止状态) } }
- 责任链模式(Chain of Responsibility)
- 将请求沿处理链传递,直到有对象处理它。
- 典型应用:审批流程、Web过滤器链。
// 1. 抽象处理者:定义审批流程的公共接口abstract class Leader {private Leader nextLeader; // 下一级审批人// 设置下一级审批人(链式调用)public Leader setNextLeader(Leader nextLeader) {this.nextLeader = nextLeader;return nextLeader; // 支持链式调用(如:leaderA.setNext(leaderB).setNext(leaderC))}// 处理请求的核心方法public final void handleRequest(int leaveDays) {if (canApprove(leaveDays)) {approve(leaveDays);} else if (nextLeader != null) {nextLeader.handleRequest(leaveDays);} else {System.out.println("请假天数过长,无人可审批!");}}// 判断是否能处理该请求(由子类实现)protected abstract boolean canApprove(int leaveDays);// 具体审批逻辑(由子类实现)protected abstract void approve(int leaveDays);}// 2. 具体处理者:项目经理(可审批0.5天内的请假)class ProjectManager extends Leader {@Overrideprotected boolean canApprove(int leaveDays) {return leaveDays <= 0.5;}@Overrideprotected void approve(int leaveDays) {System.out.println("项目经理批准请假:" + leaveDays + "天");}}// 3. 具体处理者:技术总监(可审批1天内的请假)class TechnicalDirector extends Leader {@Overrideprotected boolean canApprove(int leaveDays) {return leaveDays <= 1;}@Overrideprotected void approve(int leaveDays) {System.out.println("技术总监批准请假:" + leaveDays + "天");}}// 4. 具体处理者:总经理(可审批30天内的请假)class GeneralManager extends Leader {@Overrideprotected boolean canApprove(int leaveDays) {return leaveDays <= 30;}@Overrideprotected void approve(int leaveDays) {System.out.println("总经理批准请假:" + leaveDays + "天");}}// 5. 客户端测试public class ChainOfResponsibilityDemo {public static void main(String[] args) {// 构建责任链:项目经理 → 技术总监 → 总经理Leader projectManager = new ProjectManager();Leader technicalDirector = new TechnicalDirector();Leader generalManager = new GeneralManager();projectManager.setNextLeader(technicalDirector).setNextLeader(generalManager);// 测试不同请假天数的审批流程projectManager.handleRequest(0.5); // 项目经理处理projectManager.handleRequest(1); // 技术总监处理projectManager.handleRequest(15); // 总经理处理projectManager.handleRequest(40); // 超出所有人权限}}// 1. 抽象处理者:定义审批流程的公共接口 abstract class Leader { private Leader nextLeader; // 下一级审批人 // 设置下一级审批人(链式调用) public Leader setNextLeader(Leader nextLeader) { this.nextLeader = nextLeader; return nextLeader; // 支持链式调用(如:leaderA.setNext(leaderB).setNext(leaderC)) } // 处理请求的核心方法 public final void handleRequest(int leaveDays) { if (canApprove(leaveDays)) { approve(leaveDays); } else if (nextLeader != null) { nextLeader.handleRequest(leaveDays); } else { System.out.println("请假天数过长,无人可审批!"); } } // 判断是否能处理该请求(由子类实现) protected abstract boolean canApprove(int leaveDays); // 具体审批逻辑(由子类实现) protected abstract void approve(int leaveDays); } // 2. 具体处理者:项目经理(可审批0.5天内的请假) class ProjectManager extends Leader { @Override protected boolean canApprove(int leaveDays) { return leaveDays <= 0.5; } @Override protected void approve(int leaveDays) { System.out.println("项目经理批准请假:" + leaveDays + "天"); } } // 3. 具体处理者:技术总监(可审批1天内的请假) class TechnicalDirector extends Leader { @Override protected boolean canApprove(int leaveDays) { return leaveDays <= 1; } @Override protected void approve(int leaveDays) { System.out.println("技术总监批准请假:" + leaveDays + "天"); } } // 4. 具体处理者:总经理(可审批30天内的请假) class GeneralManager extends Leader { @Override protected boolean canApprove(int leaveDays) { return leaveDays <= 30; } @Override protected void approve(int leaveDays) { System.out.println("总经理批准请假:" + leaveDays + "天"); } } // 5. 客户端测试 public class ChainOfResponsibilityDemo { public static void main(String[] args) { // 构建责任链:项目经理 → 技术总监 → 总经理 Leader projectManager = new ProjectManager(); Leader technicalDirector = new TechnicalDirector(); Leader generalManager = new GeneralManager(); projectManager.setNextLeader(technicalDirector).setNextLeader(generalManager); // 测试不同请假天数的审批流程 projectManager.handleRequest(0.5); // 项目经理处理 projectManager.handleRequest(1); // 技术总监处理 projectManager.handleRequest(15); // 总经理处理 projectManager.handleRequest(40); // 超出所有人权限 } }
- 模板方法模式(Template Method)
- 定义算法骨架,将某些步骤延迟到子类。
- 典型应用:框架中的流程标准化(如Spring的JdbcTemplate)
// 1. 抽象类:定义饮品制作模板abstract class Beverage {// 模板方法(final 防止子类覆盖流程)public final void prepareRecipe() {boilWater();brew();pourInCup();if (customerWantsCondiments()) {addCondiments();}}// 具体方法:烧水(固定步骤)private void boilWater() {System.out.println("烧水");}// 抽象方法:冲泡(由子类实现)protected abstract void brew();// 具体方法:倒入杯子(固定步骤)private void pourInCup() {System.out.println("倒入杯子");}// 钩子方法:是否添加调料(默认返回 true,子类可覆盖)protected boolean customerWantsCondiments() {return true;}// 抽象方法:添加调料(由子类实现)protected abstract void addCondiments();}// 2. 具体子类:咖啡class Coffee extends Beverage {@Overrideprotected void brew() {System.out.println("用滤网冲泡咖啡");}@Overrideprotected void addCondiments() {System.out.println("加糖和牛奶");}// 覆盖钩子方法:黑咖啡不加调料@Overrideprotected boolean customerWantsCondiments() {return false; // 假设用户选择黑咖啡}}// 3. 具体子类:茶class Tea extends Beverage {@Overrideprotected void brew() {System.out.println("用热水浸泡茶叶");}@Overrideprotected void addCondiments() {System.out.println("加柠檬");}}// 4. 客户端测试public class TemplateMethodDemo {public static void main(String[] args) {System.out.println("=== 制作咖啡 ===");Beverage coffee = new Coffee();coffee.prepareRecipe();System.out.println("\n=== 制作茶 ===");Beverage tea = new Tea();tea.prepareRecipe();}}// 1. 抽象类:定义饮品制作模板 abstract class Beverage { // 模板方法(final 防止子类覆盖流程) public final void prepareRecipe() { boilWater(); brew(); pourInCup(); if (customerWantsCondiments()) { addCondiments(); } } // 具体方法:烧水(固定步骤) private void boilWater() { System.out.println("烧水"); } // 抽象方法:冲泡(由子类实现) protected abstract void brew(); // 具体方法:倒入杯子(固定步骤) private void pourInCup() { System.out.println("倒入杯子"); } // 钩子方法:是否添加调料(默认返回 true,子类可覆盖) protected boolean customerWantsCondiments() { return true; } // 抽象方法:添加调料(由子类实现) protected abstract void addCondiments(); } // 2. 具体子类:咖啡 class Coffee extends Beverage { @Override protected void brew() { System.out.println("用滤网冲泡咖啡"); } @Override protected void addCondiments() { System.out.println("加糖和牛奶"); } // 覆盖钩子方法:黑咖啡不加调料 @Override protected boolean customerWantsCondiments() { return false; // 假设用户选择黑咖啡 } } // 3. 具体子类:茶 class Tea extends Beverage { @Override protected void brew() { System.out.println("用热水浸泡茶叶"); } @Override protected void addCondiments() { System.out.println("加柠檬"); } } // 4. 客户端测试 public class TemplateMethodDemo { public static void main(String[] args) { System.out.println("=== 制作咖啡 ==="); Beverage coffee = new Coffee(); coffee.prepareRecipe(); System.out.println("\n=== 制作茶 ==="); Beverage tea = new Tea(); tea.prepareRecipe(); } }
- 迭代器模式(Iterator)
- 提供统一接口遍历集合元素,无需暴露内部结构。
- 典型应用:Java集合框架中的
Iterator
接口。
// 1. 迭代器接口:定义遍历方法(参考 Java 的 java.util.Iterator)interface Iterator<T> {boolean hasNext();T next();}// 2. 聚合接口:定义创建迭代器的方法(类似 java.lang.Iterable)interface Aggregate<T> {Iterator<T> createIterator();}// 3. 具体聚合类:学生集合(封装数据存储与迭代器生成)class StudentAggregate implements Aggregate<Student> {private List<Student> students = new ArrayList<>();public void addStudent(Student student) {students.add(student);}@Overridepublic Iterator<Student> createIterator() {return new StudentIterator(students); // 返回具体迭代器实例}}// 4. 具体迭代器类:实现学生集合的遍历逻辑class StudentIterator implements Iterator<Student> {private List<Student> students;private int position = 0; // 记录当前遍历位置public StudentIterator(List<Student> students) {this.students = students;}@Overridepublic boolean hasNext() {return position < students.size();}@Overridepublic Student next() {if (!hasNext()) {throw new NoSuchElementException("无更多元素"); // 越界处理}return students.get(position++);}}// 5. 学生实体类class Student {private String name;private String id;public Student(String name, String id) {this.name = name;this.id = id;}@Overridepublic String toString() {return "学生:姓名=" + name + ", 学号=" + id;}}// 6. 客户端测试public class IteratorDemo {public static void main(String[] args) {StudentAggregate aggregate = new StudentAggregate();aggregate.addStudent(new Student("张三", "S001"));aggregate.addStudent(new Student("李四", "S002"));Iterator<Student> iterator = aggregate.createIterator();while (iterator.hasNext()) {System.out.println(iterator.next());}}}=================高级集合框架=============// 支持泛型与 for-each 循环(实现 Iterable 接口)class CustomCollection<T> implements Iterable<T> {private T[] elements;@Overridepublic Iterator<T> iterator() {return new ArrayIterator<>(elements);}// 自定义数组迭代器private static class ArrayIterator<T> implements Iterator<T> {private T[] array;private int index = 0;public ArrayIterator(T[] array) {this.array = array;}@Overridepublic boolean hasNext() {return index < array.length;}@Overridepublic T next() {return array[index++];}}}// 1. 迭代器接口:定义遍历方法(参考 Java 的 java.util.Iterator) interface Iterator<T> { boolean hasNext(); T next(); } // 2. 聚合接口:定义创建迭代器的方法(类似 java.lang.Iterable) interface Aggregate<T> { Iterator<T> createIterator(); } // 3. 具体聚合类:学生集合(封装数据存储与迭代器生成) class StudentAggregate implements Aggregate<Student> { private List<Student> students = new ArrayList<>(); public void addStudent(Student student) { students.add(student); } @Override public Iterator<Student> createIterator() { return new StudentIterator(students); // 返回具体迭代器实例 } } // 4. 具体迭代器类:实现学生集合的遍历逻辑 class StudentIterator implements Iterator<Student> { private List<Student> students; private int position = 0; // 记录当前遍历位置 public StudentIterator(List<Student> students) { this.students = students; } @Override public boolean hasNext() { return position < students.size(); } @Override public Student next() { if (!hasNext()) { throw new NoSuchElementException("无更多元素"); // 越界处理 } return students.get(position++); } } // 5. 学生实体类 class Student { private String name; private String id; public Student(String name, String id) { this.name = name; this.id = id; } @Override public String toString() { return "学生:姓名=" + name + ", 学号=" + id; } } // 6. 客户端测试 public class IteratorDemo { public static void main(String[] args) { StudentAggregate aggregate = new StudentAggregate(); aggregate.addStudent(new Student("张三", "S001")); aggregate.addStudent(new Student("李四", "S002")); Iterator<Student> iterator = aggregate.createIterator(); while (iterator.hasNext()) { System.out.println(iterator.next()); } } } =================高级集合框架============= // 支持泛型与 for-each 循环(实现 Iterable 接口) class CustomCollection<T> implements Iterable<T> { private T[] elements; @Override public Iterator<T> iterator() { return new ArrayIterator<>(elements); } // 自定义数组迭代器 private static class ArrayIterator<T> implements Iterator<T> { private T[] array; private int index = 0; public ArrayIterator(T[] array) { this.array = array; } @Override public boolean hasNext() { return index < array.length; } @Override public T next() { return array[index++]; } } }
- 中介者模式(Mediator)
- 通过中介对象管理对象间交互,降低耦合。
- 典型应用:聊天室消息转发、组件协调。
// 1. 抽象中介者接口:定义通信协议interface Mediator {void register(User user); // 注册用户void relay(User sender, String message); // 转发消息}// 2. 具体中介者:聊天室服务器class ChatServer implements Mediator {private List<User> users = new ArrayList<>(); // 维护用户列表@Overridepublic void register(User user) {users.add(user);user.setMediator(this); // 用户与中介者双向绑定}@Overridepublic void relay(User sender, String message) {for (User user : users) {if (user != sender) { // 排除发送者自身user.receive(message);}}}}// 3. 抽象同事类:用户基类abstract class User {protected Mediator mediator;protected String name;public User(String name) {this.name = name;}public void setMediator(Mediator mediator) {this.mediator = mediator;}public abstract void send(String message); // 发送消息public abstract void receive(String message); // 接收消息}// 4. 具体同事类:普通用户class ChatUser extends User {public ChatUser(String name) {super(name);}@Overridepublic void send(String message) {System.out.println(name + " 发送消息:" + message);mediator.relay(this, message); // 通过中介者转发}@Overridepublic void receive(String message) {System.out.println(name + " 收到消息:" + message);}}// 5. 客户端测试public class MediatorPatternDemo {public static void main(String[] args) {// 创建中介者(聊天室服务器)Mediator server = new ChatServer();// 创建用户并注册User alice = new ChatUser("Alice");User bob = new ChatUser("Bob");User charlie = new ChatUser("Charlie");server.register(alice);server.register(bob);server.register(charlie);// 用户发送消息alice.send("大家好!");bob.send("欢迎新人!");}}// 1. 抽象中介者接口:定义通信协议 interface Mediator { void register(User user); // 注册用户 void relay(User sender, String message); // 转发消息 } // 2. 具体中介者:聊天室服务器 class ChatServer implements Mediator { private List<User> users = new ArrayList<>(); // 维护用户列表 @Override public void register(User user) { users.add(user); user.setMediator(this); // 用户与中介者双向绑定 } @Override public void relay(User sender, String message) { for (User user : users) { if (user != sender) { // 排除发送者自身 user.receive(message); } } } } // 3. 抽象同事类:用户基类 abstract class User { protected Mediator mediator; protected String name; public User(String name) { this.name = name; } public void setMediator(Mediator mediator) { this.mediator = mediator; } public abstract void send(String message); // 发送消息 public abstract void receive(String message); // 接收消息 } // 4. 具体同事类:普通用户 class ChatUser extends User { public ChatUser(String name) { super(name); } @Override public void send(String message) { System.out.println(name + " 发送消息:" + message); mediator.relay(this, message); // 通过中介者转发 } @Override public void receive(String message) { System.out.println(name + " 收到消息:" + message); } } // 5. 客户端测试 public class MediatorPatternDemo { public static void main(String[] args) { // 创建中介者(聊天室服务器) Mediator server = new ChatServer(); // 创建用户并注册 User alice = new ChatUser("Alice"); User bob = new ChatUser("Bob"); User charlie = new ChatUser("Charlie"); server.register(alice); server.register(bob); server.register(charlie); // 用户发送消息 alice.send("大家好!"); bob.send("欢迎新人!"); } }
- 备忘录模式(Memento)
- 保存对象状态以便后续恢复。
- 典型应用:游戏存档、事务回滚。
// 1. 备忘录类:存储文本编辑器的状态快照(不可变对象)class TextMemento {private final String text; // 文本内容private final int cursorPos; // 光标位置public TextMemento(String text, int cursorPos) {this.text = text;this.cursorPos = cursorPos;}// 提供访问状态的只读方法[5](@ref)public String getText() { return text; }public int getCursorPos() { return cursorPos; }}// 2. 发起人类:文本编辑器(核心业务逻辑)class TextEditor {private String text = "";private int cursorPos = 0;// 输入文本并移动光标public void write(String newText, int newPos) {this.text = newText;this.cursorPos = newPos;System.out.println("当前内容:" + text + ",光标位置:" + cursorPos);}// 创建快照public TextMemento createSnapshot() {return new TextMemento(text, cursorPos);}// 恢复快照public void restore(TextMemento memento) {this.text = memento.getText();this.cursorPos = memento.getCursorPos();System.out.println("恢复内容:" + text + ",光标位置:" + cursorPos);}}// 3. 负责人类:管理历史快照(支持多版本回退)class HistoryManager {private final List<TextMemento> snapshots = new ArrayList<>();// 保存快照public void save(TextMemento memento) {snapshots.add(memento);}// 获取指定版本快照public TextMemento get(int index) {return snapshots.get(index);}// 获取最新快照public TextMemento getLatest() {return snapshots.get(snapshots.size() - 1);}}// 4. 客户端测试public class MementoDemo {public static void main(String[] args) {TextEditor editor = new TextEditor();HistoryManager history = new HistoryManager();// 编辑并保存版本editor.write("Hello", 5);history.save(editor.createSnapshot());editor.write("Hello World", 11);history.save(editor.createSnapshot());editor.write("Hello Java!", 11);history.save(editor.createSnapshot());// 回退到第二版System.out.println("\n撤销到第二版:");editor.restore(history.get(1));// 回退到第一版System.out.println("\n撤销到第一版:");editor.restore(history.get(0));}}// 1. 备忘录类:存储文本编辑器的状态快照(不可变对象) class TextMemento { private final String text; // 文本内容 private final int cursorPos; // 光标位置 public TextMemento(String text, int cursorPos) { this.text = text; this.cursorPos = cursorPos; } // 提供访问状态的只读方法[5](@ref) public String getText() { return text; } public int getCursorPos() { return cursorPos; } } // 2. 发起人类:文本编辑器(核心业务逻辑) class TextEditor { private String text = ""; private int cursorPos = 0; // 输入文本并移动光标 public void write(String newText, int newPos) { this.text = newText; this.cursorPos = newPos; System.out.println("当前内容:" + text + ",光标位置:" + cursorPos); } // 创建快照 public TextMemento createSnapshot() { return new TextMemento(text, cursorPos); } // 恢复快照 public void restore(TextMemento memento) { this.text = memento.getText(); this.cursorPos = memento.getCursorPos(); System.out.println("恢复内容:" + text + ",光标位置:" + cursorPos); } } // 3. 负责人类:管理历史快照(支持多版本回退) class HistoryManager { private final List<TextMemento> snapshots = new ArrayList<>(); // 保存快照 public void save(TextMemento memento) { snapshots.add(memento); } // 获取指定版本快照 public TextMemento get(int index) { return snapshots.get(index); } // 获取最新快照 public TextMemento getLatest() { return snapshots.get(snapshots.size() - 1); } } // 4. 客户端测试 public class MementoDemo { public static void main(String[] args) { TextEditor editor = new TextEditor(); HistoryManager history = new HistoryManager(); // 编辑并保存版本 editor.write("Hello", 5); history.save(editor.createSnapshot()); editor.write("Hello World", 11); history.save(editor.createSnapshot()); editor.write("Hello Java!", 11); history.save(editor.createSnapshot()); // 回退到第二版 System.out.println("\n撤销到第二版:"); editor.restore(history.get(1)); // 回退到第一版 System.out.println("\n撤销到第一版:"); editor.restore(history.get(0)); } }
- 访问者模式(Visitor)
- 在不修改对象结构的前提下定义新操作。
- 典型应用:数据统计、报表生成。
// 1. 访问者接口:定义对不同商品的访问操作(参考网页1、网页3)interface Visitor {void visit(Book book);void visit(Electronic electronic);}// 2. 元素接口:声明接受访问者的方法(核心设计原则[1,3](@ref))interface Product {void accept(Visitor visitor);String getName();double getPrice();}// 3. 具体元素:书籍类(实现元素接口)class Book implements Product {private String name;private double price;public Book(String name, double price) {this.name = name;this.price = price;}@Overridepublic void accept(Visitor visitor) {visitor.visit(this); // 调用访问者的书籍处理方法[1](@ref)}@Overridepublic String getName() { return name; }@Overridepublic double getPrice() { return price; }}// 4. 具体元素:电子产品类(实现元素接口)class Electronic implements Product {private String name;private double price;public Electronic(String name, double price) {this.name = name;this.price = price;}@Overridepublic void accept(Visitor visitor) {visitor.visit(this); // 调用访问者的电子产品处理方法[1](@ref)}@Overridepublic String getName() { return name; }@Overridepublic double getPrice() { return price; }}// 5. 具体访问者:折扣计算器(实现业务逻辑扩展)class DiscountVisitor implements Visitor {@Overridepublic void visit(Book book) {double discountedPrice = book.getPrice() * 0.8; // 书籍打8折System.out.printf("书籍《%s》折扣价:%.2f元\n", book.getName(), discountedPrice);}@Overridepublic void visit(Electronic electronic) {double discountedPrice = electronic.getPrice() * 0.9; // 电子产品打9折System.out.printf("电子产品【%s】折扣价:%.2f元\n", electronic.getName(), discountedPrice);}}// 6. 对象结构:购物车(管理元素集合)class ShoppingCart {private List<Product> items = new ArrayList<>();public void addItem(Product product) {items.add(product);}public void applyDiscount(Visitor visitor) {for (Product item : items) {item.accept(visitor); // 遍历所有商品应用访问者[3,5](@ref)}}}// 7. 客户端测试public class VisitorPatternDemo {public static void main(String[] args) {// 创建商品Product book = new Book("Java设计模式", 50.0);Product phone = new Electronic("智能手机", 2000.0);// 构建购物车ShoppingCart cart = new ShoppingCart();cart.addItem(book);cart.addItem(phone);// 应用折扣访问者Visitor discountVisitor = new DiscountVisitor();cart.applyDiscount(discountVisitor);}}// 1. 访问者接口:定义对不同商品的访问操作(参考网页1、网页3) interface Visitor { void visit(Book book); void visit(Electronic electronic); } // 2. 元素接口:声明接受访问者的方法(核心设计原则[1,3](@ref)) interface Product { void accept(Visitor visitor); String getName(); double getPrice(); } // 3. 具体元素:书籍类(实现元素接口) class Book implements Product { private String name; private double price; public Book(String name, double price) { this.name = name; this.price = price; } @Override public void accept(Visitor visitor) { visitor.visit(this); // 调用访问者的书籍处理方法[1](@ref) } @Override public String getName() { return name; } @Override public double getPrice() { return price; } } // 4. 具体元素:电子产品类(实现元素接口) class Electronic implements Product { private String name; private double price; public Electronic(String name, double price) { this.name = name; this.price = price; } @Override public void accept(Visitor visitor) { visitor.visit(this); // 调用访问者的电子产品处理方法[1](@ref) } @Override public String getName() { return name; } @Override public double getPrice() { return price; } } // 5. 具体访问者:折扣计算器(实现业务逻辑扩展) class DiscountVisitor implements Visitor { @Override public void visit(Book book) { double discountedPrice = book.getPrice() * 0.8; // 书籍打8折 System.out.printf("书籍《%s》折扣价:%.2f元\n", book.getName(), discountedPrice); } @Override public void visit(Electronic electronic) { double discountedPrice = electronic.getPrice() * 0.9; // 电子产品打9折 System.out.printf("电子产品【%s】折扣价:%.2f元\n", electronic.getName(), discountedPrice); } } // 6. 对象结构:购物车(管理元素集合) class ShoppingCart { private List<Product> items = new ArrayList<>(); public void addItem(Product product) { items.add(product); } public void applyDiscount(Visitor visitor) { for (Product item : items) { item.accept(visitor); // 遍历所有商品应用访问者[3,5](@ref) } } } // 7. 客户端测试 public class VisitorPatternDemo { public static void main(String[] args) { // 创建商品 Product book = new Book("Java设计模式", 50.0); Product phone = new Electronic("智能手机", 2000.0); // 构建购物车 ShoppingCart cart = new ShoppingCart(); cart.addItem(book); cart.addItem(phone); // 应用折扣访问者 Visitor discountVisitor = new DiscountVisitor(); cart.applyDiscount(discountVisitor); } }
- 解释器模式(Interpreter)
- 定义语法规则并解释语言中的句子。
- 典型应用:正则表达式解析、规则引擎。
import java.util.HashMap;import java.util.Map;// 1. 抽象表达式接口(定义解释操作)interface Expression {int interpret(Context context);}// 2. 终结符表达式:数字常量class Number implements Expression {private int value;public Number(int value) {this.value = value;}@Overridepublic int interpret(Context context) {return value; // 直接返回数值}}// 3. 非终结符表达式:加法运算class Add implements Expression {private Expression left;private Expression right;public Add(Expression left, Expression right) {this.left = left;this.right = right;}@Overridepublic int interpret(Context context) {return left.interpret(context) + right.interpret(context); // 递归解释左右表达式}}// 4. 非终结符表达式:减法运算class Subtract implements Expression {private Expression left;private Expression right;public Subtract(Expression left, Expression right) {this.left = left;this.right = right;}@Overridepublic int interpret(Context context) {return left.interpret(context) - right.interpret(context); // 递归解释左右表达式}}// 5. 上下文环境(可存储变量信息,本示例未使用变量)class Context {// 预留变量存储空间(示例中仅作结构演示)private Map<String, Integer> variables = new HashMap<>();public void setVariable(String name, int value) {variables.put(name, value);}public int getVariable(String name) {return variables.getOrDefault(name, 0);}}// 6. 客户端测试public class InterpreterPatternDemo {public static void main(String[] args) {// 构建表达式:5 + (3 - 2) + 7Expression expr = new Add(new Add(new Number(5),new Subtract(new Number(3), new Number(2))),new Number(7));// 解释执行Context context = new Context();int result = expr.interpret(context);System.out.println("计算结果:" + result); // 输出:13}}import java.util.HashMap; import java.util.Map; // 1. 抽象表达式接口(定义解释操作) interface Expression { int interpret(Context context); } // 2. 终结符表达式:数字常量 class Number implements Expression { private int value; public Number(int value) { this.value = value; } @Override public int interpret(Context context) { return value; // 直接返回数值 } } // 3. 非终结符表达式:加法运算 class Add implements Expression { private Expression left; private Expression right; public Add(Expression left, Expression right) { this.left = left; this.right = right; } @Override public int interpret(Context context) { return left.interpret(context) + right.interpret(context); // 递归解释左右表达式 } } // 4. 非终结符表达式:减法运算 class Subtract implements Expression { private Expression left; private Expression right; public Subtract(Expression left, Expression right) { this.left = left; this.right = right; } @Override public int interpret(Context context) { return left.interpret(context) - right.interpret(context); // 递归解释左右表达式 } } // 5. 上下文环境(可存储变量信息,本示例未使用变量) class Context { // 预留变量存储空间(示例中仅作结构演示) private Map<String, Integer> variables = new HashMap<>(); public void setVariable(String name, int value) { variables.put(name, value); } public int getVariable(String name) { return variables.getOrDefault(name, 0); } } // 6. 客户端测试 public class InterpreterPatternDemo { public static void main(String[] args) { // 构建表达式:5 + (3 - 2) + 7 Expression expr = new Add( new Add(new Number(5), new Subtract(new Number(3), new Number(2))), new Number(7) ); // 解释执行 Context context = new Context(); int result = expr.interpret(context); System.out.println("计算结果:" + result); // 输出:13 } }
© 版权声明
文章版权归作者所有,未经允许请勿转载。
相关文章
暂无评论...