【设计模式】委托模式和代理模式

委托模式和代理模式都是常见的设计模式，它们都涉及到对象之间的协作和交互，但是它们的实现方式和应用场景有所不同。

委托模式（Delegate Pattern）

委托模式（Delegate Pattern）是一种对象组合的方式，其中一个对象将任务委托给另一个对象来执行，从而实现任务的分配和协作。委托模式可以使得对象之间的耦合度降低，可以支持动态地切换委托对象等功能。委托模式的经典应用场景是事件处理机制，其中一个对象将事件委托给另一个对象来处理。
委托模式示例代码

// 定义一个 Task 接口，表示任务
interface Task {
    void doTask(); // 定义一个 doTask() 方法，用于执行任务
}

// 定义一个 TaskA 类，实现 Task 接口，表示任务A
class TaskA implements Task {
    @Override
    public void doTask() { // 实现 Task 接口中的 doTask() 方法
        System.out.println("TaskA is running."); // 输出任务A正在执行
    }
}

// 定义一个 TaskB 类，实现 Task 接口，表示任务B
class TaskB implements Task {
    @Override
    public void doTask() { // 实现 Task 接口中的 doTask() 方法
        System.out.println("TaskB is running."); // 输出任务B正在执行
    }
}

// 定义一个 TaskDelegate 类，实现 Task 接口，表示任务委托
class TaskDelegate implements Task {
    private Task task; // 定义一个 Task 类型的 task，表示任务

    public TaskDelegate(Task task) { // 定义一个带参构造方法，用于创建 TaskDelegate 对象
        this.task = task;
    }

    @Override
    public void doTask() { // 实现 Task 接口中的 doTask() 方法
        task.doTask(); // 调用 task 的 doTask() 方法
    }
}

public class DelegatePatternDemo {
    public static void main(String[] args) {
        Task taskA = new TaskA(); // 创建一个 TaskA 对象
        Task taskB = new TaskB(); // 创建一个 TaskB 对象

        TaskDelegate delegateA = new TaskDelegate(taskA); // 创建一个 TaskDelegate 对象，表示任务A的委托
        TaskDelegate delegateB = new TaskDelegate(taskB); // 创建一个 TaskDelegate 对象，表示任务B的委托

        delegateA.doTask(); // 执行任务A的委托
        delegateB.doTask(); // 执行任务B的委托
    }
}

代理模式

代理模式（Proxy Pattern）是一种对象结构型模式，其中一个对象充当另一个对象的代理，以控制对该对象的访问。代理模式可以实现对象的延迟加载、对象的访问控制、对象的保护代理等功能。代理模式的经典应用场景是远程代理、虚拟代理、保护代理等。
代理模式示例代码

// 定义一个 Image 接口，表示图像
interface Image {
    void display(); // 定义一个 display() 方法，用于显示图像
}

// 定义一个 RealImage 类，实现 Image 接口，表示真实图像
class RealImage implements Image {
    private String fileName; // 定义一个字符串类型的 fileName，表示文件名

    public RealImage(String fileName) { // 定义一个带参构造方法，用于创建 RealImage 对象
        this.fileName = fileName;
        loadFromDisk(fileName); // 加载文件
    }

    @Override
    public void display() { // 实现 Image 接口中的 display() 方法
        System.out.println("Displaying " + fileName); // 输出文件名
    }

    private void loadFromDisk(String fileName) { // 定义一个 loadFromDisk() 方法，用于加载文件
        System.out.println("Loading " + fileName); // 输出加载文件信息
    }
}

// 定义一个 ProxyImage 类，实现 Image 接口，表示代理图像
class ProxyImage implements Image {
    private RealImage realImage; // 定义一个 RealImage 类型的 realImage，表示真实图像
    private String fileName; // 定义一个字符串类型的 fileName，表示文件名

    public ProxyImage(String fileName) { // 定义一个带参构造方法，用于创建 ProxyImage 对象
        this.fileName = fileName;
    }

    @Override
    public void display() { // 实现 Image 接口中的 display() 方法
        if (realImage == null) { // 如果真实图像为空
            realImage = new RealImage(fileName); // 创建一个 RealImage 对象
        }
        realImage.display(); // 显示真实图像
  
	}
}

public class ProxyPatternDemo {
public static void main(String[] args) {
Image image = new ProxyImage("test.jpg"); // 创建一个 ProxyImage 对象，表示代理图像
image.display(); // 显示图像

    System.out.println();

    image.display(); // 再次显示图像
	}
}