外观模式，，，

最新推荐文章于 2025-04-09 10:28:46 发布

原创最新推荐文章于 2025-04-09 10:28:46 发布 · 599 阅读

24 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

收录于

设计模式

还有三个模式就结束结构型模式了，

视频已经过半了

最后一个行为模式，

一共23个，

创建型 5 个，单例，工厂，抽象工厂，原型，建造者

结构型 7 个，代理，装饰器，适配器，桥接，

行为型， 11 个，

理解了就行，过一遍就行，不会一无所知就行

然后是 jvm

设计模式

设计模式可以分为三大类：创建型、结构型 和 行为型。你提到的这些模式属于这些分类，具体情况如下：

1. 创建型模式（5个）

创建型模式主要关注对象创建的过程，帮助在不同的情境下创建对象时提高灵活性和可扩展性。

单例模式（Singleton）：确保一个类只有一个实例，并提供全局访问点。
工厂模式（Factory）：通过一个工厂方法来创建对象，而不是直接使用构造函数。
抽象工厂模式（Abstract Factory）：提供一个接口，用于创建一系列相关或依赖对象的工厂。
原型模式（Prototype）：通过复制现有的实例来创建新的对象，而不是重新创建一个新的对象。
建造者模式（Builder）：将一个复杂对象的构建过程分解为多个步骤，允许逐步构建不同的对象。

2. 结构型模式（7个）

结构型模式主要关注如何将类和对象组合成更大的结构，通常涉及到继承和组合。

代理模式（Proxy）：通过代理对象控制对原始对象的访问，可以进行延迟加载、权限控制等。
装饰器模式（Decorator）：通过动态地给对象增加额外的功能，而不修改原有代码。
适配器模式（Adapter）：将一个类的接口转换成客户端希望的接口，使原本不兼容的接口可以协同工作。
桥接模式（Bridge）：将抽象部分与实现部分分离，使得两者可以独立变化，通常用于处理复杂的层次结构。

3. 行为型模式（11个）

行为型模式主要关注对象之间的交互和责任分配，适用于不同对象之间协作和通信的场景。

责任链模式（Chain of Responsibility）
命令模式（Command）
解释器模式（Interpreter）
迭代器模式（Iterator）
中介者模式（Mediator）
备忘录模式（Memento）
观察者模式（Observer）
状态模式（State）
策略模式（Strategy）
模板方法模式（Template Method）
访问者模式（Visitor）

JVM相关知识

JVM（Java虚拟机）是Java程序运行的环境，它提供了跨平台的能力。以下是一些你可能需要了解的关键点：

JVM架构：JVM由多个部分组成，包括类加载器、运行时数据区、执行引擎、垃圾回收器等。
内存管理：
- 堆（Heap）：存储所有对象实例。
- 栈（Stack）：存储方法调用和局部变量。
- 方法区（Method Area）：存储类信息、常量、静态变量等数据。
垃圾回收：JVM自动进行内存管理，垃圾回收器回收不再使用的对象，减少内存泄漏和溢出的风险。
字节码：Java编译器将Java源代码编译成字节码，JVM解释或即时编译字节码为机器代码来执行。

你提到“过一遍就行，不会一无所知就行”，如果是为了对设计模式和JVM有一个大致的了解，这样的学习方式是有效的。你可以先了解每个模式的核心思想和适用场景，之后再深入研究具体的实现。对于JVM，掌握内存管理和垃圾回收机制也是非常重要的。

外观模式，很简单

外观模式（Facade Pattern）

定义：
外观模式（Facade Pattern）是结构型设计模式的一种，旨在为复杂的子系统提供一个统一的接口，使得客户端通过这个简单的接口与复杂的子系统进行交互。外观模式隐藏了系统的复杂性，提供一个简洁的接口，让客户端只需要了解外观类，而不需要了解子系统的内部实现细节。

适用场景：

当你需要为复杂的系统提供一个简单的接口。
当系统的各个模块或类之间的耦合度较高时，外观模式可以减少客户端与子系统之间的直接交互，从而降低耦合度。
当客户端只关心子系统的功能，而不需要知道其实现时。

组成：

外观模式主要由以下角色组成：

外观类（Facade）：为客户端提供简单的接口，隐藏子系统内部的复杂性。
子系统类（Subsystem）：实现具体的功能逻辑，子系统的类通常是一些细节实现，外部类通过外观类与它们进行交互。

优缺点：

优点：

简化客户端代码：客户端只需要和外观类打交道，而不需要直接和子系统的复杂类进行交互。
解耦：外观模式减少了客户端和子系统之间的耦合，使得子系统的修改对客户端的影响最小。
便于维护：将复杂的子系统进行封装，减少了系统的复杂度，便于系统的维护和扩展。

缺点：

外观类可能变得过于庞大：如果子系统非常复杂，外观类可能会变得非常大，甚至违反单一职责原则。
无法替代子系统中的功能：外观模式将一些功能隐藏起来，但并不改变子系统本身的复杂性，如果客户端需要更细粒度的控制，可能不适合使用外观模式。

示例代码：

假设我们有一个家庭影院系统，其中包括了多个复杂的子系统，如音响、投影仪、DVD播放器等。使用外观模式可以为家庭影院系统提供一个简洁的操作接口。

// 子系统1：音响
class AudioSystem {
    public void on() {
        System.out.println("Audio system is on.");
    }
    public void off() {
        System.out.println("Audio system is off.");
    }
    public void setVolume(int volume) {
        System.out.println("Audio system volume set to " + volume);
    }
}

// 子系统2：投影仪
class Projector {
    public void on() {
        System.out.println("Projector is on.");
    }
    public void off() {
        System.out.println("Projector is off.");
    }
    public void setInput(String input) {
        System.out.println("Projector input set to " + input);
    }
}

// 子系统3：DVD播放器
class DVDPlayer {
    public void on() {
        System.out.println("DVD Player is on.");
    }
    public void off() {
        System.out.println("DVD Player is off.");
    }
    public void play(String movie) {
        System.out.println("Playing movie: " + movie);
    }
    public void stop() {
        System.out.println("Stopping movie.");
    }
}

// 外观类：家庭影院外观
class HomeTheaterFacade {
    private AudioSystem audioSystem;
    private Projector projector;
    private DVDPlayer dvdPlayer;

    public HomeTheaterFacade(AudioSystem audio, Projector projector, DVDPlayer dvdPlayer) {
        this.audioSystem = audio;
        this.projector = projector;
        this.dvdPlayer = dvdPlayer;
    }

    public void watchMovie(String movie) {
        System.out.println("Get ready to watch a movie...");
        projector.on();
        projector.setInput("DVD");
        audioSystem.on();
        audioSystem.setVolume(5);
        dvdPlayer.on();
        dvdPlayer.play(movie);
    }

    public void endMovie() {
        System.out.println("Shutting down movie theater...");
        dvdPlayer.stop();
        dvdPlayer.off();
        audioSystem.off();
        projector.off();
    }
}

// 客户端代码
public class FacadePatternExample {
    public static void main(String[] args) {
        AudioSystem audio = new AudioSystem();
        Projector projector = new Projector();
        DVDPlayer dvdPlayer = new DVDPlayer();

        HomeTheaterFacade homeTheater = new HomeTheaterFacade(audio, projector, dvdPlayer);

        // 客户端调用外观类的方法
        homeTheater.watchMovie("Inception");
        System.out.println("Movie is playing...");
        homeTheater.endMovie();
    }
}

运行结果：

Get ready to watch a movie...
Projector is on.
Projector input set to DVD
Audio system is on.
Audio system volume set to 5
DVD Player is on.
Playing movie: Inception
Movie is playing...
Shutting down movie theater...
Stopping movie.
DVD Player is off.
Audio system is off.
Projector is off.

分析：

子系统类（AudioSystem、Projector、DVDPlayer） 负责实际的功能实现，每个类都具有独立的操作方法。
外观类（HomeTheaterFacade） 提供了 watchMovie 和 endMovie 方法，客户端只需调用这两个方法来控制家庭影院的所有操作，而无需了解具体的细节（如音响的音量、投影仪的输入、DVD播放器的播放等）。

通过外观模式，客户端的代码更加简洁，系统的复杂度也被有效地封装和隐藏。

结论：

外观模式通过提供一个高层接口，简化了复杂系统的使用方式，降低了客户端与复杂子系统之间的耦合度。它适用于子系统相对复杂，且客户端只需要执行一系列复杂操作时。

外观模式就是加一层封装。

可以理解外观模式（Facade Pattern）就是通过添加一层“封装”来简化复杂系统的使用。通过外观类，客户端可以避免直接与复杂子系统的各个部分交互，从而减少代码的复杂性和耦合度。

外观模式的核心思想是：将子系统的复杂性隐藏在外观类中，客户端只需要通过外观类提供的简单接口与系统进行交互，而不需要知道各个子系统内部的实现细节。

简单总结：

封装：外观模式通过提供一个统一的接口，将复杂的操作封装成简单的方法，客户端调用时无需了解细节。
简化使用：通过外观类，客户端的操作变得简单，避免了直接操作复杂的子系统。

这种封装不仅仅是代码的组织，还是设计上的一种简化。让客户端能够更容易地与系统交互，同时维护和扩展复杂的子系统变得更为高效。

例如在家庭影院的例子中，客户端无需关心音响、投影仪、DVD播放器如何操作，只需通过外观类调用 watchMovie 或 endMovie，就可以轻松实现所有相关的操作。

比如自动售卖机，就是外观模式，提供了简单使用

自动售卖机可以视为一个典型的外观模式的应用。它将复杂的内部操作封装起来，提供一个简单且易于使用的界面，用户只需通过选择商品、付款等简单操作即可完成交易，而无需了解背后复杂的物品管理、库存控制、支付系统等细节。

自动售卖机作为外观模式的示例：

在自动售卖机的实现中，用户的交互非常简单，通常就是按下一个按钮，选择商品、付款、取货等步骤。但是，这个看似简单的操作背后涉及多个系统模块的协作，例如：

硬币识别系统：用于识别并验证投币。
商品库存管理系统：用于检查商品是否有库存。
支付系统：处理现金或电子支付的操作。
商品配送系统：将商品从库存中取出并交给用户。
界面显示系统：显示商品信息、操作提示等。

这些模块和系统可能非常复杂，但通过外观模式，它们的细节被封装在一个统一的接口中。用户和客户端只需与这个简化的外观接口（自动售卖机的控制面板）进行交互。

结论：

通过外观模式，自动售卖机将复杂的内部逻辑（例如硬币验证、库存检查、支付处理等）封装在外部接口中，用户只需要通过简单的操作就能完成交易。这种方式使得用户与系统之间的交互更加简单，而不需要了解背后的复杂操作。

外观模式也符合结构型，就是加一些结构，实现一些功能。

结构型模式概念

结构型设计模式关注的是如何将类或对象组合成更大的结构。结构型模式通过简化、重新组织和调整现有的组件，使得系统的结构更加清晰、更易于使用和维护。外观模式通过添加一个“外观”类来封装复杂的子系统结构，提供一个更简单的接口。

外观模式的作用

外观模式通过将复杂的子系统与外部代码分离，提供一个统一的高层接口，使得客户端代码不需要直接和复杂的子系统交互，从而简化了代码的结构。

外观模式的实现方式

外观模式通过创建一个外观类来隐藏复杂的子系统，它的主要任务是协调和调用各个子系统组件的功能，并将这些细节封装到一个易于使用的接口中。

外观模式的结构：

Facade（外观类）：提供高层次的接口，简化外部调用，隐藏复杂的实现。
Subsystem（子系统类）：实现具体的功能和业务逻辑，通常子系统是一些比较复杂的模块，外观类通过它们来提供服务。

外观模式的类图示例：

        +-----------------+
        |   Facade        | <--- 提供简化的接口
        +-----------------+
        | +methodA()      |
        | +methodB()      |
        +-----------------+
                |
   +------------+------------+
   |                         |
+-----------+           +-----------+
| SubsystemA |           | SubsystemB |
+-----------+           +-----------+
| +operation1() |       | +operation2() |
+-----------+           +-----------+