外观设计模式

现实世界中的例子

你是如何打开电脑的呢？"按下电源键"，你说！你之所以这么认为，是因为你使用的是电脑提供的外部简单界面，而电脑内部需要执行很多操作才能实现这一点。这个简单界面背后的复杂子系统就是一个外观（Facade）。

用简单的话来说

外观模式为复杂的子系统提供了一个简化的接口。

维基百科的说法

外观是一个对象，它为较大的代码体（如类库）提供了一个简化的接口。

外观模式的核心思想：

外观模式的核心目的是为复杂子系统提供一个统一的接口，隐藏了系统内部复杂性，简化了客户端的使用。就像在电脑上，你只需要按下电源按钮，而不需要了解内部复杂的启动过程。外观模式帮助将这些复杂操作封装到一个简单的接口中。

C++ 代码实现：

1. 复杂子系统类（Computer）：

Computer 类模拟了计算机的不同操作，它包含了多个复杂的操作，真实情况下可能涉及硬件控制、软件启动等。

2. 外观类（ComputerFacade）：

ComputerFacade 类提供了简化的接口，用户通过这个类来控制计算机的开关，而不需要了解底层的复杂操作。

C++ 示例代码：

cpp 复制代码

#include <iostream>
#include <string>

// 复杂子系统：Computer 类
class Computer {
public:
    // 计算机通电，模拟电流通过的过程
    void getElectricShock() {
        std::cout << "Ouch!" << std::endl;
    }

    // 启动时发出声音
    void makeSound() {
        std::cout << "Beep beep!" << std::endl;
    }

    // 显示加载画面
    void showLoadingScreen() {
        std::cout << "Loading.." << std::endl;
    }

    // 计算机准备好使用时的状态
    void bam() {
        std::cout << "Ready to be used!" << std::endl;
    }

    // 关闭计算机时的操作
    void closeEverything() {
        std::cout << "Bup bup bup buzzzz!" << std::endl;
    }

    // 计算机关机后的状态
    void sooth() {
        std::cout << "Zzzzz" << std::endl;
    }

    // 拔掉电源线
    void pullCurrent() {
        std::cout << "Haaah!" << std::endl;
    }
};

// 外观类：ComputerFacade
class ComputerFacade {
private:
    Computer* computer;  // 持有一个 Computer 类的对象

public:
    // 构造函数，接受一个 Computer 对象
    ComputerFacade(Computer* comp) : computer(comp) {}

    // 开机操作，简化了一系列复杂的操作
    void turnOn() {
        computer->getElectricShock();  // 通过电流
        computer->makeSound();         // 发出声音
        computer->showLoadingScreen(); // 显示加载画面
        computer->bam();               // 准备好使用
    }

    // 关机操作，简化了一系列复杂的关闭操作
    void turnOff() {
        computer->closeEverything();   // 关闭所有程序
        computer->pullCurrent();       // 拔掉电源
        computer->sooth();             // 让计算机进入休眠
    }
};

// 主函数
int main() {
    // 创建计算机对象
    Computer* myComputer = new Computer();

    // 创建外观类对象，并传入计算机对象
    ComputerFacade* computerFacade = new ComputerFacade(myComputer);

    // 开机
    std::cout << "Turning on the computer:" << std::endl;
    computerFacade->turnOn();  // 输出：Ouch! Beep beep! Loading.. Ready to be used!

    // 关机
    std::cout << "\nTurning off the computer:" << std::endl;
    computerFacade->turnOff(); // 输出：Bup bup buzz! Haaah! Zzzzz

    // 释放资源
    delete computerFacade;
    delete myComputer;

    return 0;
}

代码讲解：

1. Computer 类：

这个类模拟了一个计算机的多种操作，包括开机、关机、显示加载画面等复杂的步骤。每个方法都是一个计算机操作的具体实现，实际上可能会涉及硬件和操作系统的交互。你可以把它看作是计算机内部的"复杂子系统"。

cpp 复制代码

class Computer {
public:
    void getElectricShock() {
        std::cout << "Ouch!" << std::endl;
    }

    void makeSound() {
        std::cout << "Beep beep!" << std::endl;
    }

    void showLoadingScreen() {
        std::cout << "Loading.." << std::endl;
    }

    void bam() {
        std::cout << "Ready to be used!" << std::endl;
    }

    void closeEverything() {
        std::cout << "Bup bup bup buzzzz!" << std::endl;
    }

    void sooth() {
        std::cout << "Zzzzz" << std::endl;
    }

    void pullCurrent() {
        std::cout << "Haaah!" << std::endl;
    }
};

2. ComputerFacade 类：

ComputerFacade 类提供了一个简化的接口，使得用户不需要了解计算机启动和关机的具体实现。用户只需要调用 turnOn() 或 turnOff() 方法，这两个方法会调用 Computer 类中的多个方法来完成一个复杂的操作。

cpp 复制代码

class ComputerFacade {
private:
    Computer* computer;  // 持有一个 Computer 类的对象

public:
    // 构造函数，接受一个 Computer 对象
    ComputerFacade(Computer* comp) : computer(comp) {}

    // 开机操作，简化了一系列复杂的操作
    void turnOn() {
        computer->getElectricShock();  // 通过电流
        computer->makeSound();         // 发出声音
        computer->showLoadingScreen(); // 显示加载画面
        computer->bam();               // 准备好使用
    }

    // 关机操作，简化了一系列复杂的关闭操作
    void turnOff() {
        computer->closeEverything();   // 关闭所有程序
        computer->pullCurrent();       // 拔掉电源
        computer->sooth();             // 让计算机进入休眠
    }
};

3. main() 函数：

在 main() 函数中，我们通过 ComputerFacade 来调用 turnOn() 和 turnOff() 方法，用户只需要使用这两个简单的接口，而不需要关心计算机内部的具体操作。

cpp 复制代码

int main() {
    // 创建计算机对象
    Computer* myComputer = new Computer();

    // 创建外观类对象，并传入计算机对象
    ComputerFacade* computerFacade = new ComputerFacade(myComputer);

    // 开机
    std::cout << "Turning on the computer:" << std::endl;
    computerFacade->turnOn();  // 输出：Ouch! Beep beep! Loading.. Ready to be used!

    // 关机
    std::cout << "\nTurning off the computer:" << std::endl;
    computerFacade->turnOff(); // 输出：Bup bup buzz! Haaah! Zzzzz

    // 释放资源
    delete computerFacade;
    delete myComputer;

    return 0;
}

运行结果：

cpp 复制代码

Turning on the computer:
Ouch!
Beep beep!
Loading..
Ready to be used!

Turning off the computer:
Bup bup bup buzzzz!
Haaah!
Zzzzz

总结：

外观模式通过为复杂的子系统（如计算机的启动和关闭过程）提供一个简单的接口，简化了客户端的调用。
Computer 类是内部系统，包含了复杂的操作。
ComputerFacade 类是外观类，提供了简化的接口，用户只需要调用 turnOn() 或 turnOff() 方法，而不需要关心内部如何实现这些操作。
外观模式主要用于隐藏系统的复杂性，使得客户端与系统的交互更加简洁。