JAVA设计模式

• ​​创建型模式​​：解决对象创建问题（如单例、工厂）
• ​​结构型模式​​：优化对象组合方式（如适配器、代理）
• ​​行为型模式​​：管理对象间协作（如观察者、策略）

一、创建型模式（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");
    }
}

• ​​工厂方法模式（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();

• ​​抽象工厂模式（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); // 确保硬件兼容性
    }
}

• ​​建造者模式（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);
    }
}

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);
    }
}

---

​​二、结构型模式（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();
    }
}

• ​​桥接模式（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(); // 绘制绿色的圆形
    }
}

• ​​组合模式（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);
    }
}

• ​​装饰器模式（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());
    }
}

• ​​外观模式（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();
    }
}

• ​​享元模式（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());
    }
}

• ​​代理模式（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();
    }
}

---

​​三、行为型模式（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框架实战指南");
    }
}

• ​​策略模式（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());
    }
}

• ​​命令模式（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();     // 输出：灯已关闭 → 灯已打开 → 灯已关闭
    }
}

• ​​状态模式（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();      // 输出：电梯紧急停止（切换为停止状态）
    }
}

• ​​责任链模式（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);    // 超出所有人权限
    }
}

• ​​模板方法模式（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();
    }
}

• ​​迭代器模式（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++];
        }
    }
}

• ​​中介者模式（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("欢迎新人！");
    }
}

• ​​备忘录模式（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));
    }
}

• ​​访问者模式（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);
    }
}

• ​​解释器模式（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
    }
}

---

​