JAVA设计模式

JAVA1个月前更新 D-Mr
48 0

文章目录

  • deepseek模型
  • JAVA
  • PHP
  • 个人数据信息泄露自检测
  • 挖币
  • 显卡
  • 短剧
  • 站长收藏
  • 谷歌插件
  • 账户购买
    • ​创建型模式​​:解决对象创建问题(如单例、工厂)
    • ​结构型模式​​:优化对象组合方式(如适配器、代理)
    • ​行为型模式​​:管理对象间协作(如观察者、策略)

    一、创建型模式(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 {
    @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();
    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 {
    @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); // 确保硬件兼容性
    }
    }
    // ================== 抽象产品定义 ================== 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;
    }
    @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);
    }
    }
    /​**​ * 产品类:电脑(包含多个可选参数) */ 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); } }
    1. ​原型模式(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(">>> 完成基础软件安装(耗时操作)");
    }
    //---------- 浅拷贝实现 ----------
    @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);
    }
    }
    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 {
    @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();
    }
    }
    // ================== 目标接口 ================== /​**​ * 目标接口: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 {
    @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(); // 绘制绿色的圆形
    }
    }
    // ================== 实现部分接口:颜色渲染 ================== /​**​ * 颜色接口(实现部分) * 定义图形填充颜色的具体实现规范[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);
    }
    @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);
    }
    }
    /​**​ * 组件抽象类(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 {
    @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());
    }
    }
    // 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;
    }
    @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());
    }
    }
    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 {
    @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();
    }
    }
    // 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;
    }
    @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框架实战指南");
    }
    }
    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 {
    @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());
    }
    }
    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;
    }
    @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(); // 输出:灯已关闭 → 灯已打开 → 灯已关闭
    }
    }
    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;
    }
    @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(); // 输出:电梯紧急停止(切换为停止状态)
    }
    }
    // 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 {
    @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); // 超出所有人权限
    }
    }
    // 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 {
    @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();
    }
    }
    // 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);
    }
    @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++];
    }
    }
    }
    // 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<>(); // 维护用户列表
    @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("欢迎新人!");
    }
    }
    // 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;
    }
    @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);
    }
    }
    // 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;
    }
    @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
    }
    }
    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 } }

    © 版权声明

    相关文章

    暂无评论

    none
    暂无评论...