结构型设计模式（一）：门面模式 & 组合模式

门面模式 Facade

1、什么是门面模式

门面模式（Facade Pattern）是一种结构型设计模式，旨在为系统提供一个统一的接口，以便于访问子系统中的一群接口。它通过定义一个高层接口，简化了客户端与子系统之间的交互，从而降低了系统的复杂性。

2、为什么使用门面模式

1. 简化接口：门面模式通过定义一个高层接口，简化了客户端与子系统之间的交互，使得客户端无需直接与子系统的复杂接口打交道。
2. 解耦客户端和子系统：通过引入门面，客户端与子系统的依赖关系得到解耦，客户端只需与门面进行交互，而不需要关心子系统的具体实现。
3. 提高可维护性：门面模式将子系统的实现细节封装起来，有助于提高系统的可维护性，降低了系统的复杂性。

3、如何实现门面模式

设计实现一个简单的计算启动过程

// 子系统 - CPU
class CPU {
    public void start() {
        System.out.println("CPU is starting...");
    }
}

// 子系统 - Memory
class Memory {
    public void load() {
        System.out.println("Memory is loading...");
    }
}

// 子系统 - HardDrive
class HardDrive {
    public void read() {
        System.out.println("HardDrive is reading...");
    }
}

// 门面类 - ComputerFacade
class ComputerFacade {
    private CPU cpu;
    private Memory memory;
    private HardDrive hardDrive;

    public ComputerFacade() {
        this.cpu = new CPU();
        this.memory = new Memory();
        this.hardDrive = new HardDrive();
    }

    public void startComputer() {
        cpu.start();
        memory.load();
        hardDrive.read();
        System.out.println("Computer is started and ready to use.");
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        ComputerFacade computerFacade = new ComputerFacade();
        computerFacade.startComputer();
    }
}

4、是否存在缺陷和不足

1. 不符合开闭原则：当系统中的子系统发生变化时，可能需要修改门面类，不符合开闭原则。
2. 可能导致过多门面类：随着系统的不断扩展，可能会出现多个门面类，导致系统变得复杂。

5、如何缓解缺陷和不足

1. 使用配置文件：将子系统的配置信息放置在配置文件中，通过读取配置文件的方式动态创建门面类，提高系统的灵活性。
2. 使用抽象工厂模式：可以结合抽象工厂模式，将门面的创建过程交给工厂类，从而降低客户端与门面的耦合度。

// 抽象产品 - CPU
interface CPU {
    void start();
}

// 具体产品A - ConcreteCPUA
class ConcreteCPUA implements CPU {
    @Override
    public void start() {
        System.out.println("ConcreteCPUA is starting...");
    }
}

// 具体产品B - ConcreteCPUB
class ConcreteCPUB implements CPU {
    @Override
    public void start() {
        System.out.println("ConcreteCPUB is starting...");
    }
}

// 抽象产品 - Memory
interface Memory {
    void load();
}

// 具体产品A - ConcreteMemoryA
class ConcreteMemoryA implements Memory {
    @Override
    public void load() {
        System.out.println("ConcreteMemoryA is loading...");
    }
}

// 具体产品B - ConcreteMemoryB
class ConcreteMemoryB implements Memory {
    @Override
    public void load() {
        System.out.println("ConcreteMemoryB is loading...");
    }
}

// 抽象产品 - HardDrive
interface HardDrive {
    void read();
}

// 具体产品A - ConcreteHardDriveA
class ConcreteHardDriveA implements HardDrive {
    @Override
    public void read() {
        System.out.println("ConcreteHardDriveA is reading...");
    }
}

// 具体产品B - ConcreteHardDriveB
class ConcreteHardDriveB implements HardDrive {
    @Override
    public void read() {
        System.out.println("ConcreteHardDriveB is reading...");
    }
}

// 抽象工厂接口
interface ComputerFactory {
    CPU createCPU();
    Memory createMemory();
    HardDrive createHardDrive();
}

// 具体工厂A
class ConcreteFactoryA implements ComputerFactory {
    @Override
    public CPU createCPU() {
        return new ConcreteCPUA();
    }

    @Override
    public Memory createMemory() {
        return new ConcreteMemoryA();
    }

    @Override
    public HardDrive createHardDrive() {
        return new ConcreteHardDriveA();
    }
}

// 具体工厂B
class ConcreteFactoryB implements ComputerFactory {
    @Override
    public CPU createCPU() {
        return new ConcreteCPUB();
    }

    @Override
    public Memory createMemory() {
        return new ConcreteMemoryB();
    }

    @Override
    public HardDrive createHardDrive() {
        return new ConcreteHardDriveB();
    }
}

// 门面类
class ComputerFacade {
    private CPU cpu;
    private Memory memory;
    private HardDrive hardDrive;

    public ComputerFacade(ComputerFactory factory) {
        this.cpu = factory.createCPU();
        this.memory = factory.createMemory();
        this.hardDrive = factory.createHardDrive();
    }

    public void startComputer() {
        cpu.start();
        memory.load();
        hardDrive.read();
        System.out.println("Computer is started and ready to use.");
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        // 使用工厂A创建电脑
        ComputerFactory factoryA = new ConcreteFactoryA();
        ComputerFacade computerFacadeA = new ComputerFacade(factoryA);
        computerFacadeA.startComputer();

        // 使用工厂B创建电脑
        ComputerFactory factoryB = new ConcreteFactoryB();
        ComputerFacade computerFacadeB = new ComputerFacade(factoryB);
        computerFacadeB.startComputer();
    }
}

上面这个例子中，抽象工厂模式用于创建不同系列的电脑产品，而门面类的创建过程交给工厂类，客户端代码通过选择不同的工厂来创建不同系列的电脑，无需关心具体产品的创建过程，有助于提高系统的灵活性和可维护性

组合模式 Composite

1、什么是组合模式

组合模式通过将对象组织成树形结构来表示整体-部分层次结构，使得客户端可以统一对待单个对象和对象的组合。它主要包含三个角色：叶子节点（Leaf）、组合节点（Composite）、客户端（Client）。

2、为什么使用组合模式

1. 统一接口：组合模式使得客户端可以统一对待单个对象和对象的组合，因为它们共享相同的接口。
2. 灵活性：客户端无需关心对象是叶子节点还是组合节点，可以在不同层次构建复杂的对象结构。
3. 简化客户端代码：客户端无需判断操作的是单个对象还是对象组合，简化了客户端代码。

3、如何使用组合模式

设计实现一个文件系统

import java.util.ArrayList;
import java.util.List;

// 抽象组件 - 文件和目录的共同接口
interface FileSystemComponent {
    void display();
}

// 叶子节点 - 文件
class FileLeaf implements FileSystemComponent {
    private String name;

    public FileLeaf(String name) {
        this.name = name;
    }

    @Override
    public void display() {
        System.out.println("File: " + name);
    }
}

// 组合节点 - 目录
class DirectoryComposite implements FileSystemComponent {
    private String name;
    private List<FileSystemComponent> components;

    public DirectoryComposite(String name) {
        this.name = name;
        this.components = new ArrayList<>();
    }

    public void addComponent(FileSystemComponent component) {
        components.add(component);
    }

    public void removeComponent(FileSystemComponent component) {
        components.remove(component);
    }

    @Override
    public void display() {
        System.out.println("Directory: " + name);
        for (FileSystemComponent component : components) {
            component.display();
        }
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        // 构建文件系统结构
        FileSystemComponent file1 = new FileLeaf("file1.txt");
        FileSystemComponent file2 = new FileLeaf("file2.txt");

        DirectoryComposite dir1 = new DirectoryComposite("Folder 1");
        dir1.addComponent(file1);
        dir1.addComponent(file2);

        FileSystemComponent file3 = new FileLeaf("file3.txt");
        DirectoryComposite dir2 = new DirectoryComposite("Folder 2");
        dir2.addComponent(file3);
        dir2.addComponent(dir1);

        // 显示文件系统结构
        dir2.display();
    }
}

4、是否存在缺陷和不足

1. 限制类型一致性：组合模式要求所有组件都实现相同的接口，这可能限制了组件的类型一致性。
2. 不支持单个对象的特殊处理：组合模式统一对待单个对象和组合对象，因此可能无法支持对单个对象的特殊处理。

5、如何缓解缺陷和不足

1. 使用抽象构件类：引入一个抽象构建类，包含所有子类共有的方法，从而提高组件的类型一致性。
2. 在叶子节点实现特殊处理：在叶子节点类中实现特殊处理逻辑，以满足对单个对象的特殊需求。