免费赠送 :《Java面试宝典》 持续更新+ 史上最全 + 面试必备 2000页 + 大厂必备 +涨薪必备]

22 道 Java 设计模式高频核心面试题

1. 简述什么是设计模式？

设计模式（Design Pattern）是软件开发中的一种通用的、可复用的解决方案模板，用于解决特定情境下常见的设计问题。它不是一段可以直接执行的代码，而是一种描述某一类问题解决方案的设计思路，帮助开发者在面对相似问题时快速找到合适的解决方法。

设计模式通常包含以下几个要素：

1. 模式名称：一个助记名，用来标识该模式。
2. 问题：描述了该模式适用的问题场景或需求。
3. 解决方案：详细说明如何解决问题，包括类和对象的组织方式。
4. 效果：讨论使用该模式后的利弊，以及对系统的影响。

根据其目的和应用领域，设计模式可以分为以下几类：

1. 创建型模式（Creational Patterns）：关注对象的创建机制，旨在将对象的创建与使用分离。常见的创建型模式有：

   • 单例模式（Singleton）
   • 工厂方法模式（Factory Method）
   • 抽象工厂模式（Abstract Factory）
   • 建造者模式（Builder）

2. 结构型模式（Structural Patterns）：关注类和对象的组合，帮助设计更灵活的接口或实现。常见的结构型模式有：

   • 适配器模式（Adapter）
   • 装饰器模式（Decorator）
   • 代理模式（Proxy）
   • 桥接模式（Bridge）

3. 行为型模式（Behavioral Patterns）：关注对象之间的职责分配和交互方式。常见的行为型模式有：

   • 策略模式（Strategy）
   • 观察者模式（Observer）
   • 命令模式（Command）
   • 状态模式（State）

通过合理运用设计模式，开发者可以提高代码的可读性、可维护性和灵活性，同时也能更好地遵循面向对象设计原则，如单一职责原则、开放封闭原则等。

2-叙述常见Java设计模式分类

Java设计模式可以按照其目的和使用场景分为三大类：创建型模式、结构型模式和行为型模式。下面我将分别介绍这三类模式，并列举一些常见的设计模式。

1. 创建型模式（Creational Patterns）

创建型模式主要关注对象的创建，目的是为了将对象的创建与使用分离，提供更灵活的对象创建方式。常见的创建型模式包括：

• 单例模式（Singleton Pattern）
  确保一个类只有一个实例，并提供一个全局访问点。常用于需要控制资源访问的场景，如数据库连接池。

• 工厂方法模式（Factory Method Pattern）
  定义一个用于创建对象的接口，但由子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到子类。

• 抽象工厂模式（Abstract Factory Pattern）
  提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。适用于多个产品族的场景。

• 建造者模式（Builder Pattern）
  将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。适用于需要逐步构造复杂对象的场景。

• 原型模式（Prototype Pattern）
  通过复制现有对象来创建新对象，而不是通过常规的构造函数。适用于创建代价高昂的对象时，可以通过复制已有对象提高效率。

---

2. 结构型模式（Structural Patterns）

结构型模式主要用于处理类或对象的组合，帮助设计出更灵活、可复用的代码。常见的结构型模式包括：

• 适配器模式（Adapter Pattern）
  将一个类的接口转换成客户希望的另一个接口，使得原本不兼容的接口能够一起工作。

• 桥接模式（Bridge Pattern）
  将抽象部分与它的实现部分分离，使它们都可以独立变化。适用于需要动态切换实现的情况。

• 组合模式（Composite Pattern）
  将对象组合成树形结构以表示“部分-整体”的层次结构，使得用户对单个对象和组合对象具有一致性。

• 装饰模式（Decorator Pattern）
  动态地给一个对象添加一些额外的职责，而不改变其接口。适用于需要在运行时扩展对象功能的场景。

• 外观模式（Facade Pattern）
  为子系统中的一组接口提供一个一致的界面，简化复杂的子系统接口。适用于需要隐藏复杂系统的内部细节时。

• 享元模式（Flyweight Pattern）
  运用共享技术有效地支持大量细粒度的对象，减少内存占用。适用于需要创建大量相似对象的场景。

• 代理模式（Proxy Pattern）
  为其他对象提供一种代理以控制对这个对象的访问。适用于需要控制对象访问权限或延迟初始化的场景。

---

3. 行为型模式（Behavioral Patterns）

行为型模式专注于对象之间的通信和职责分配，帮助设计出更具灵活性和可维护性的代码。常见的行为型模式包括：

• 策略模式（Strategy Pattern）
  定义一系列算法，把它们一个个封装起来，并且使它们可以互相替换。适用于需要根据上下文选择不同算法的场景。

• 观察者模式（Observer Pattern）
  定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并自动更新。

• 命令模式（Command Pattern）
  将请求封装成对象，从而使你可以用不同的请求对客户进行参数化。适用于需要解耦请求发送者和接收者的场景。

• 责任链模式（Chain of Responsibility Pattern）
  使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。

• 状态模式（State Pattern）
  允许一个对象在其内部状态改变时改变它的行为，对象看起来似乎修改了它的类。适用于对象的行为依赖于其状态，并且状态之间可以相互转换的场景。

• 模板方法模式（Template Method Pattern）
  定义一个操作中的算法骨架，而将一些步骤延迟到子类中实现。适用于需要定义固定流程，但某些步骤可能因具体需求而变化的场景。

• 迭代器模式（Iterator Pattern）
  提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露其内部表示。适用于需要遍历集合或容器的场景。

• 中介者模式（Mediator Pattern）
  用一个中介对象来封装一系列的对象交互，使得各对象不需要显式引用彼此，从而降低耦合度。

• 备忘录模式（Memento Pattern）
  在不破坏封装的前提下，捕获一个对象的内部状态，并在需要时恢复该状态。

3-Java 设计模式的六大原则

Java设计模式的六大原则，也常被称为SOLID+DIP原则（最后的D有时会被单独列出），这些原则旨在指导开发者创建更灵活、可维护和可扩展的软件。以下是这六大原则的详细介绍：

1. 单一职责原则 (Single Responsibility Principle, SRP)
   每个类应该仅有一个引起它变化的原因，即一个类只负责一项功能或职责。
   目的在于降低类的复杂性，提高代码的可读性和可维护性。

2. 开闭原则 (Open/Closed Principle, OCP)
   软件实体（类、模块、函数等）应该对扩展开放，对修改关闭。
   这意味着我们应该能够通过增加新代码来实现新的功能，而不是改变已有的代码，从而减少引入错误的风险。

3. 里氏替换原则 (Liskov Substitution Principle, LSP)
   子类型必须能够替换它们的基类型，而程序的行为不会发生改变。
   确保继承关系中的子类可以完全替代父类使用，保证了代码的稳定性和可预测性。

4. 接口隔离原则 (Interface Segregation Principle, ISP)
   客户端不应该依赖于它不使用的方法。
   接口应该尽量小且专注于特定的功能，避免定义过于庞大或复杂的接口，让实现类只需关注自己需要的部分。

5. 依赖倒置原则 (Dependency Inversion Principle, DIP)
   高层模块不应该依赖低层模块，两者都应该依赖于抽象；抽象不应该依赖细节，细节应该依赖抽象。
   通过依赖注入等方式解耦合，使系统更加灵活，易于测试和维护。

6. 迪米特法则 (Law of Demeter, LoD) 或最少知识原则
   一个对象应当对其他对象有尽可能少的了解。
   减少对象之间的直接交互，使得系统的各个部分相对独立，降低了耦合度，提高了模块化程度。

遵循上述原则可以帮助我们构建出结构良好、易于理解和维护的应用程序。在实际开发过程中，理解并灵活运用这些原则是非常重要的。

4-简述对 MVC 的理解， MVC 有什么优缺点？

MVC（Model-View-Controller）简介

MVC 是一种软件架构设计模式，用于将应用程序分为三个主要部分：模型（Model）、视图（View）和控制器（Controller）。这种分层结构有助于提高代码的可维护性、可扩展性和可测试性。

1. Model（模型）：负责处理数据逻辑和业务规则。它与数据库交互，执行数据验证、计算等操作，并提供数据给视图。
2. View（视图）：负责展示数据和用户界面。视图从模型中获取数据并以图形化的方式呈现给用户，同时也可以接收用户的输入。
3. Controller（控制器）：作为模型和视图之间的桥梁，负责处理用户输入，调用模型中的方法来更新数据，并选择适当的视图来显示结果。

MVC 的优点

1. 分离关注点：MVC 将应用程序的不同方面分开，使得每个部分都可以独立开发和测试。例如，前端开发者可以专注于视图的设计，而后端开发者可以专注于模型和控制器的实现。
2. 提高代码复用性：由于视图和模型是分离的，因此可以在不同的视图中复用相同的模型逻辑，或者在不同的应用中复用相同的模型代码。
3. 支持多视图：一个模型可以有多个视图，适用于不同设备或不同用户的需求。例如，Web 应用程序可以有一个桌面版视图和一个移动版视图。
4. 易于维护和扩展：由于代码结构清晰，开发者可以更容易地理解和修改现有代码，添加新功能时也不会影响其他部分。
5. 支持团队协作：前端和后端开发者可以并行工作，互不干扰，加快开发进度。

MVC 的缺点

1. 复杂度增加：对于小型项目或简单的应用程序，引入 MVC 可能会增加不必要的复杂度。过多的抽象层可能导致开发人员难以理解系统的整体结构。
2. 性能开销：由于 MVC 需要通过控制器来协调模型和视图之间的通信，可能会引入额外的性能开销，尤其是在需要频繁更新数据的应用场景中。
3. 学习曲线：对于初学者来说，掌握 MVC 模式的概念和实现可能需要一定的时间，尤其是在处理复杂的业务逻辑时。
4. 过度解耦的风险：虽然解耦有助于提高灵活性，但如果设计不当，可能会导致各部分之间的依赖关系变得过于松散，反而增加了调试和维护的难度。

总结

MVC 是一种非常流行的架构模式，特别适合于大型、复杂的 Web 应用程序和桌面应用程序。它的主要优势在于能够很好地分离关注点，提高代码的可维护性和可扩展性。然而，在某些情况下，特别是对于小型项目，MVC 可能会引入不必要的复杂度。因此，在选择是否使用 MVC 时，应该根据项目的具体需求和规模进行权衡。

5-简述什么是典型的软件三层结构？软件设计为什么要分层？

典型的软件三层结构

典型的软件三层结构通常指的是将应用程序划分为三个独立的层次，每个层次负责不同的功能。这三层分别是：

1. 表示层（Presentation Layer）
   也称为用户界面层或前端层，主要负责与用户的交互。它处理用户输入、展示数据，并提供友好的用户界面。常见的实现技术包括网页、移动应用界面等。

2. 业务逻辑层（Business Logic Layer, BLL）
   这一层是核心部分，负责处理应用程序的核心业务规则和逻辑。它定义了系统的功能和操作，确保数据在系统中正确地流转和处理。业务逻辑层不直接与用户交互，而是通过表示层接收请求并返回结果。

3. 数据访问层（Data Access Layer, DAL）
   该层负责与数据库或其他持久化存储进行交互，执行数据的读取、写入、更新和删除操作。它为业务逻辑层提供数据支持，确保数据的完整性和一致性。

软件设计为什么要分层？

分层设计的主要目的是为了提高软件的可维护性、可扩展性和灵活性。具体原因如下：

1. 职责分离（Separation of Concerns）
   每一层只关注自己特定的功能，避免了代码的混乱和重复。这种清晰的职责划分使得开发人员可以专注于某一层次的功能实现，而不会受到其他层次的影响。

2. 易于维护和修改
   当某个功能需要修改时，开发人员只需要针对特定的层次进行调整，而不需要改动整个系统。例如，如果要更换数据库，只需修改数据访问层，而不影响业务逻辑层和表示层。

3. 模块化开发
   分层结构使得不同层次的开发可以并行进行，团队成员可以根据自己的专长分别负责不同的层次，提高了开发效率。

4. 可测试性
   分层设计使得每一层都可以独立进行单元测试，确保每个模块的功能正确无误。这样可以在早期发现问题，减少后期集成时的风险。

5. 适应变化
   随着需求的变化，分层结构可以让系统更容易适应新的需求。例如，当需要添加新的功能时，可以通过扩展某一层来实现，而不需要对整个系统进行大规模重构。

总之，分层设计是一种有效的架构模式，能够帮助开发者构建更加稳定、灵活和易于维护的软件系统。

6. 简述什么是单例模式，以及它解决的问题，应用的环境？

单例模式（Singleton Pattern）是一种创建型设计模式，它确保一个类在程序运行期间只有一个实例，并提供一个全局访问点来访问这个唯一的实例。其核心思想是控制实例的数量，确保某个类的对象唯一存在。

单例模式解决的问题

1. 资源消耗：某些对象的创建和销毁过程可能非常耗费资源（如数据库连接、线程池等），通过单例模式可以避免频繁创建和销毁对象，从而节省系统资源。
2. 数据一致性：当多个模块需要共享同一份数据时，使用单例模式可以确保所有模块操作的是同一个对象，从而保证数据的一致性。
3. 协调管理：例如，在多线程环境中，确保只有一个线程能够执行特定的操作，或者确保某个配置文件只被加载一次。

单例模式的应用环境

1. 配置管理：例如，应用程序中只有一个配置文件读取器，所有模块都通过该读取器获取配置信息。
2. 日志记录：日志记录器通常只需要一个实例，所有的日志信息都通过这一个实例进行处理。
3. 数据库连接池：为了提高性能，数据库连接池通常实现为单例模式，以确保整个应用只维护一个连接池。
4. 工厂模式中的工厂类：如果工厂类本身不需要多个实例，可以将其设计为单例模式。
5. 跨进程通信：在某些情况下，确保不同进程之间共享同一个资源或对象。

实现方式

单例模式可以通过多种方式实现，常见的有懒汉式、饿汉式、双重检查锁（DCL）、静态内部类等。每种实现方式都有其优缺点，适用于不同的场景。

懒汉式（Lazy Initialization）

• 优点：延迟初始化，只有在第一次使用时才创建实例。
• 缺点：需要考虑线程安全问题。

public class Singleton {
    private static Singleton instance;
    private Singleton() {}
    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

饿汉式（Eager Initialization）

• 优点：简单易懂，线程安全。
• 缺点：类加载时就初始化，可能会浪费资源。

public class Singleton {
    private static final Singleton instance = new Singleton();
    private Singleton() {}
    public static Singleton getInstance() {
        return instance;
    }
}

双重检查锁（Double-Checked Locking）

• 优点：既实现了延迟加载，又保证了线程安全。
• 缺点：代码稍微复杂一些。

public class Singleton {
    private volatile static Singleton instance;
    private Singleton() {}
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

静态内部类

• 优点：线程安全，延迟加载，且实现简单。
• 缺点：Java 特有的实现方式。

public class Singleton {
    private Singleton() {}
    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }
    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

总之，单例模式在实际开发中有着广泛的应用，特别是在需要控制资源使用和确保数据一致性的场景下。选择合适的实现方式取决于具体的应用场景和需求。

7- 简述什么是工厂模式，以及它解决的问题，应用的环境？

工厂模式（Factory Pattern）是一种常用的软件设计模式，属于创建型设计模式。它提供了一种创建对象的接口，但由子类决定实例化哪一个类。工厂模式让类的实例化过程延迟到子类，从而将对象的创建和使用分离。

工厂模式的核心概念

1. 工厂类：负责创建对象。
2. 产品接口或抽象类：定义产品的公共接口。
3. 具体产品类：实现产品接口的具体类。

---

工厂模式的类型

1. 简单工厂模式：通过一个工厂类来创建对象，但它不是严格的设计模式，因为它违反了开放-封闭原则（修改时需要改动工厂类）。
2. 工厂方法模式：定义一个用于创建对象的接口，让子类决定实例化哪个类。
3. 抽象工厂模式：提供一个创建一系列相关或依赖对象的接口，而无需指定它们具体的类。

---

解决的问题

工厂模式主要解决以下问题：

1. 解耦对象的创建与使用：通过将对象的创建封装在工厂中，调用者无需知道具体的产品类名，降低了代码之间的耦合度。
2. 支持扩展性：当需要新增产品时，只需添加新的具体产品类和对应的工厂类，而无需修改现有的代码。
3. 简化复杂的对象创建过程：如果对象的创建逻辑复杂（例如需要根据条件选择不同的实现），工厂模式可以将这些逻辑封装起来，使客户端代码更加简洁。

---

应用环境

工厂模式适用于以下场景：

1. 需要屏蔽对象创建的细节：当对象的创建过程较为复杂，或者不希望客户端直接了解如何创建对象时。
2. 需要灵活扩展产品线：当系统需要支持多种产品类型，并且可能在未来新增产品时。
3. 对象创建依赖于动态条件：根据不同的条件创建不同的对象，而不是通过硬编码实现。
4. 多平台或多版本兼容：当需要为不同平台或版本提供不同的实现时，可以通过工厂模式统一管理。

---

示例

假设有一个应用需要支持多种支付方式（如支付宝、微信支付等）。可以通过工厂模式来实现：

// 抽象产品：支付接口
public interface Payment {
    void pay();
}

// 具体产品：支付宝支付
public class Alipay implements Payment {
    @Override
    public void pay() {
        System.out.println("使用支付宝支付");
    }
}

// 具体产品：微信支付
public class WechatPay implements Payment {
    @Override
    public void pay() {
        System.out.println("使用微信支付");
    }
}

// 工厂类
public class PaymentFactory {
    public static Payment createPayment(String type) {
        if ("alipay".equals(type)) {
            return new Alipay();
        } else if ("wechat".equals(type)) {
            return new WechatPay();
        } else {
            throw new IllegalArgumentException("未知的支付类型");
        }
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Payment payment = PaymentFactory.createPayment("alipay");
        payment.pay(); // 输出：使用支付宝支付
    }
}

在这个例子中，PaymentFactory 负责根据输入类型创建具体的支付对象，而客户端代码无需关心具体实现。

---

总结来说，工厂模式是一种优雅的解决方案，用于处理对象创建过程中可能出现的复杂性和扩展性需求。

8-简述什么是值对象模式，以及它解决的问题，应用的环境？

值对象模式（Value Object Pattern）

1. 定义：

值对象模式是一种设计模式，主要用于表示那些不可变的、具有固有属性的对象。值对象的核心特性是它的“值”而不是它的标识。换句话说，两个值对象如果包含相同的值，那么它们就是相等的，而不像实体对象那样依赖于唯一标识符。

2. 解决的问题：

• 一致性问题：在系统中，某些对象的属性组合在一起时，应该被视为一个整体。例如，地址、货币、颜色等。值对象模式通过将这些属性封装在一个不可变的对象中，确保了数据的一致性。

• 性能问题：对于频繁使用的简单对象（如日期、金额等），使用实体对象会导致不必要的复杂性和性能开销。值对象模式通过减少对象的状态管理来提高性能。

• 可读性和可维护性：值对象模式使得代码更具可读性和可维护性，因为它清晰地表达了哪些对象是基于值进行比较的，而不是基于标识。

3. 应用环境：

• 领域驱动设计（DDD）：在DDD中，值对象通常用于表示那些不具有唯一标识的领域概念。例如，在订单系统中，Money、Address 等可以作为值对象。

• 不可变对象场景：当对象一旦创建后不应该被修改时，值对象模式非常适用。例如，日期时间、货币、几何形状等。

• 需要保证数据一致性的场景：当多个地方使用相同的数据组合时，值对象可以确保这些组合的一致性。例如，用户地址在订单和配送信息中应该是完全相同的。

• 高性能需求的场景：当系统对性能要求较高时，值对象可以通过减少状态管理和对象引用的方式来提高效率。

4. 特点：

• 不可变性：值对象一旦创建，其属性就不能再被修改。任何对值对象的操作都会返回一个新的值对象实例。

• 相等性基于值：两个值对象是否相等取决于它们的值是否相等，而不是它们的引用是否相同。

• 无身份标识：值对象没有唯一的标识符，因此不能根据身份来区分它们。

5. 示例：

假设我们有一个 Money 类作为值对象：

public final class Money {
    private final String currency;
    private final BigDecimal amount;

    public Money(String currency, BigDecimal amount) {
        this.currency = currency;
        this.amount = amount;
    }

    // 不允许修改，所有方法都返回新的 Money 对象
    public Money add(Money other) {
        if (!this.currency.equals(other.currency)) {
            throw new IllegalArgumentException("Currencies must match");
        }
        return new Money(this.currency, this.amount.add(other.amount));
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Money money = (Money) obj;
        return Objects.equals(currency, money.currency) &&
                Objects.equals(amount, money.amount);
    }

    @Override
    public int hashCode() {
        return Objects.hash(currency, amount);
    }
}

在这个例子中，Money 是一个不可变的值对象，它通过值（货币和金额）来确定对象的相等性，并且提供了不可变的行为。

总结：

值对象模式适用于那些不需要唯一标识、关注数据值一致性、并且需要高性能处理的场景。通过使用值对象模式，可以简化系统的设计，提高代码的可读性和性能。

9- 请代码示例：值对象模式的实现方法

值对象模式（Value Object Pattern）是一种设计模式，通常用于表示不可变的对象，这些对象通过其属性的值来定义。值对象通常是轻量级的，并且在比较时基于它们的内容而不是引用。

下面是一个使用 Python 实现值对象模式的示例代码：

from dataclasses import dataclass, field
from typing import Any
import copy

@dataclass(frozen=True, eq=True)
class ValueObject:
    """
    值对象的基类
    """
    def __post_init__(self):
        # 确保对象是不可变的
        if not self.__class__.__frozen__:
            raise AttributeError("ValueObject should be immutable.")
    
    def __copy__(self):
        # 值对象应该是不可变的，因此不需要深拷贝
        return self

    def __deepcopy__(self, memo: dict) -> Any:
        return self

@dataclass(frozen=True, eq=True)
class Money(ValueObject):
    """
    一个具体的值对象：Money
    """
    amount: float
    currency: str

    def convert_to_usd(self, exchange_rate: float) -> 'Money':
        """
        将货币转换为美元
        """
        new_amount = self.amount * exchange_rate
        return Money(amount=new_amount, currency="USD")

# 使用示例
if __name__ == "__main__":
    money1 = Money(amount=100, currency="EUR")
    money2 = Money(amount=100, currency="EUR")
    money3 = Money(amount=200, currency="EUR")
    
    print(money1 == money2)  # 输出: True，因为值相同
    print(money1 == money3)  # 输出: False，因为值不同
    
    converted_money = money1.convert_to_usd(exchange_rate=1.1)
    print(converted_money)  # 输出: Money(amount=110.0, currency='USD')

代码说明：

1. ValueObject 类：这是一个抽象的值对象基类，使用了 dataclass 来简化数据类的定义，并设置了 frozen=True 来确保对象是不可变的。

2. Money 类：这是一个具体的值对象，继承自 ValueObject。它有两个属性：amount 和 currency。我们还添加了一个方法 convert_to_usd，用于将货币转换为美元。

3. 不可变性：通过 frozen=True，我们确保了 Money 对象一旦创建就不能被修改。

4. 比较：由于设置了 eq=True，两个 Money 对象可以通过它们的值进行比较，而不是通过引用。

5. 深拷贝和浅拷贝：值对象应该是不可变的，因此不需要深拷贝或浅拷贝，直接返回自身即可。

这个例子展示了如何使用值对象模式来创建不可变的对象，并且通过内容进行比较。

10-请问什么是DAO模式？

DAO模式（Data Access Object）

DAO模式是一种设计模式，用于将数据访问逻辑与业务逻辑分离。它提供了一个抽象层，使得应用程序的其他部分不需要直接与数据库或其他持久化存储进行交互。通过使用DAO模式，可以提高代码的可维护性和灵活性，同时也更容易进行单元测试。

主要特点：

1. 封装数据访问逻辑
   DAO负责与数据库、文件系统或任何其他持久化存储进行交互。它隐藏了具体的实现细节，如SQL查询、ORM映射等。

2. 提供统一接口
   DAO为不同的数据源提供一致的接口。无论是关系型数据库、NoSQL数据库还是文件系统，应用程序都可以通过相同的接口进行操作。

3. 解耦业务逻辑和数据访问逻辑
   通过将数据访问逻辑封装在DAO中，业务逻辑层不再需要关心如何获取或存储数据，从而降低了耦合度。

4. 支持多种持久化技术
   DAO模式允许轻松切换不同的持久化机制，而不需要修改业务逻辑代码。例如，可以从MySQL切换到MongoDB，只需要替换相应的DAO实现。

通常的DAO方法包括：

• create() 或 insert()：插入新记录。
• read() 或 get()：根据主键或其他条件查询记录。
• update()：更新现有记录。
• delete()：删除记录。
• find() 或 list()：查询多个记录。

示例：

假设我们有一个User实体类，对应的DAO接口可能如下：

public interface UserDao {
    User getUserById(int id); // 根据ID获取用户
    List<User> getAllUsers(); // 获取所有用户
    void createUser(User user); // 创建新用户
    void updateUser(User user); // 更新用户信息
    void deleteUser(int id); // 删除用户
}

然后，我们可以为这个接口提供一个具体的实现类，比如UserDaoImpl，它会包含与数据库交互的具体逻辑。

DAO模式的优点：

• 易于维护：数据访问逻辑集中在DAO类中，便于维护和调试。
• 易于扩展：如果需要更改数据源或持久化机制，只需修改DAO实现，而不需要改动业务逻辑。
• 提高了代码复用性：不同模块可以通过相同的DAO接口访问数据，减少了重复代码。

DAO模式的缺点：

• 增加了代码量：由于需要为每个实体创建单独的DAO接口和实现类，可能会增加代码量。
• 过度抽象：对于简单的应用，DAO模式可能显得过于复杂，增加了不必要的抽象层次。

总的来说，DAO模式是一个非常有用的设计模式，特别是在复杂的、需要与多种数据源交互的应用程序中。它通过将数据访问逻辑与业务逻辑分离，提高了代码的可维护性和灵活性。

11 - 简述Spring开发中的哪里使用了工厂设计模式？

在Spring开发中，工厂设计模式被广泛使用，尤其体现在依赖注入（DI）和对象创建的过程中。以下是几个关键点，展示了Spring框架如何利用工厂设计模式：

1. BeanFactory
   这是Spring IoC容器的核心接口之一，它负责管理bean的创建、配置和生命周期。BeanFactory可以被视为一个工厂类，它根据配置信息（如XML文件或注解）动态地创建和管理bean实例。

2. ApplicationContext
   它是BeanFactory的子接口，提供了更丰富的功能，比如支持国际化、事件传播等。ApplicationContext同样遵循工厂模式，它不仅能够创建和管理bean，还可以通过不同方式（如文件系统、类路径下等）加载配置元数据，并根据这些元数据来构建应用程序上下文环境。

3. FactoryBean
   这是一个特殊的接口，允许开发者自定义bean的创建逻辑。实现FactoryBean接口后，可以通过该接口的方法来生成复杂的对象实例，而不仅仅是简单的JavaBean。例如，您可以使用FactoryBean来封装第三方库的对象创建过程，从而更好地集成到Spring应用中。

4. BeanPostProcessor 和 BeanFactoryPostProcessor
   这两个接口允许我们在bean实例化前后进行一些额外的操作。虽然它们不是直接的工厂模式体现，但它们确实影响了bean的实际创建流程，属于广义上的工厂模式的应用场景。

5. 自动装配（Autowiring）
   当使用@Autowired或其他形式的自动装配时，Spring会根据类型或名称查找合适的bean并注入到目标对象中。这个过程也是基于工厂模式的原理，即由Spring容器负责管理和提供所需的依赖对象。

总之，在Spring框架里，从最基本的bean创建到复杂的业务逻辑处理，工厂模式无处不在，极大地简化了开发工作，提高了代码的可维护性和灵活性。

12. 简述什么是代理模式？

代理模式（Proxy Pattern）是一种结构型设计模式，它通过提供一个代理对象来控制对另一个对象的访问。代理对象充当客户端与目标对象之间的中介，可以在不修改目标对象的情况下，添加额外的功能或控制逻辑。

代理模式的主要角色：

1. Subject（抽象主题类）：定义了真实对象和代理对象的公共接口，使得代理对象可以替代真实对象。
2. RealSubject（真实主题类）：实现了抽象主题类中的业务逻辑，是代理对象所代表的真实对象。
3. Proxy（代理类）：持有对真实主题对象的引用，并在调用其方法时进行一些额外的操作（如权限检查、延迟加载、日志记录等）。

代理模式的常见应用场景：

• 远程代理（Remote Proxy）：为远程对象提供本地表示，隐藏网络通信细节。
• 虚拟代理（Virtual Proxy）：延迟初始化开销较大的对象，只有在需要时才创建真实对象。
• 保护代理（Protection Proxy）：控制对真实对象的访问权限。
• 智能引用（Smart Reference）：在访问对象时执行一些附加操作，如计数、日志记录等。

优点：

• 封装性增强：可以通过代理对象隐藏真实对象的实现细节。
• 功能扩展：可以在不修改真实对象的情况下，为其添加新的功能。
• 性能优化：例如通过虚拟代理实现懒加载，减少不必要的资源消耗。

缺点：

• 复杂度增加：引入代理对象会增加系统的复杂度，尤其是在多个代理层嵌套的情况下。

总之，代理模式在许多场景下可以帮助我们更好地控制对象的访问和行为，同时保持代码的灵活性和可维护性。

13. 请列举代理模式Java应用场景

代理模式（Proxy Pattern）在Java中是一种结构型设计模式，它为其他对象提供一种代理以控制对这个对象的访问。代理模式可以用于多种场景，以下是Java中常见的应用场景：

1. 远程代理（Remote Proxy）

• 场景：当需要通过网络访问远程对象时，可以使用远程代理。代理对象负责与远程对象进行通信，并将结果返回给客户端。
• 例子：RMI（Remote Method Invocation）或分布式系统中的服务调用。

2. 虚拟代理（Virtual Proxy）

• 场景：用于延迟加载大型对象或资源密集型对象。代理对象会先创建一个轻量级的代理对象，在真正需要时才加载实际的对象。
• 例子：图像加载器，只有在用户真正点击图片时才加载高分辨率的图片。

3. 保护代理（Protection Proxy）

• 场景：用于控制对原始对象的访问权限。代理可以根据调用者的身份或权限来决定是否允许访问原始对象。
• 例子：文件系统中的权限控制，某些用户只能读取文件，而另一些用户可以写入文件。

4. 缓存代理（Cache Proxy）

• 场景：用于缓存昂贵的操作结果，避免重复计算或频繁访问数据库等资源。代理对象会在第一次请求时执行实际操作并缓存结果，后续请求直接从缓存中获取。
• 例子：Web应用程序中的页面缓存，或者数据库查询结果的缓存。

5. 智能引用代理（Smart Reference Proxy）

• 场景：用于跟踪对象的使用情况，例如记录对象的访问次数、时间戳等。代理可以在每次访问时执行额外的操作。
• 例子：统计某个对象被调用的次数，或者记录最后一次访问的时间。

6. 日志代理（Logging Proxy）

• 场景：在调用目标对象之前或之后记录日志信息。代理可以在方法调用前后插入日志记录逻辑。
• 例子：记录方法的调用时间和参数，或者记录方法的返回值和异常信息。

7. 动态代理（Dynamic Proxy）

• 场景：动态代理是Java中非常强大的特性，允许在运行时创建代理类。它可以用于AOP（面向切面编程）、事务管理、权限控制等多种场景。
• 例子：Spring框架中的AOP实现，使用动态代理来拦截方法调用并添加横切关注点（如日志、事务等）。

8. 同步代理（Synchronization Proxy）

• 场景：用于确保线程安全。代理可以在多个线程访问共享资源时，确保只有一个线程能够访问。
• 例子：多线程环境下的单例模式实现，确保只有一个实例被创建。

9. 防火墙代理（Firewall Proxy）

• 场景：用于在网络层面上过滤请求，防止非法访问。代理可以根据预定义的规则拦截或转发请求。
• 例子：Web应用防火墙（WAF），阻止恶意请求到达服务器。

10. 智能指针（Smart Pointer）

• 场景：用于自动管理对象的生命周期，类似于C++中的智能指针。代理可以在对象不再被使用时自动释放资源。
• 例子：JVM中的垃圾回收机制，虽然不是手动实现的代理，但类似的概念可以帮助管理资源。

总结

代理模式的核心思想是通过引入中间层来控制对目标对象的访问，从而实现诸如权限控制、延迟加载、日志记录等功能。在Java中，代理模式的应用非常广泛，尤其是在框架开发和企业级应用中，代理模式常常与其他设计模式结合使用，提升系统的灵活性和可维护性。

14-简述什么是原型模式？

原型模式（Prototype Pattern）是一种创建型设计模式，它允许通过复制现有对象来创建新对象，而无需深入了解其具体类。这种方式可以提高性能并简化对象的创建过程，特别是在对象创建成本较高或复杂的情况下。

原型模式的核心思想：

1. 复制现有对象：通过克隆一个现有的对象来生成新的对象实例，而不是通过传统的构造函数创建。
2. 避免复杂的初始化：当对象的创建过程较为复杂（例如需要大量的参数配置或依赖注入），可以通过复制已配置好的对象来简化创建过程。
3. 浅拷贝与深拷贝：根据需求选择是进行浅拷贝（只复制对象本身，引用类型的成员仍然共享同一引用）还是深拷贝（递归地复制所有引用类型的成员）。

主要角色：

• Prototype（抽象原型类）：声明克隆自身的接口。
• ConcretePrototype（具体原型类）：实现克隆操作的具体方法。
• Client（客户端）：使用原型类来创建新对象。

优点：

• 减少子类构建：无需为每个子类编写复杂的构造函数，直接通过克隆已有对象即可。
• 性能优化：在某些情况下，克隆对象比创建新对象更高效。
• 灵活配置：可以先创建一个部分配置好的对象，然后通过克隆和修改来快速生成多个相似的对象。

缺点：

• 深拷贝复杂性：如果对象包含复杂的嵌套结构，深拷贝可能会比较困难且耗时。
• 依赖于具体的实现：克隆操作依赖于对象的具体实现，可能会影响代码的可维护性。

原型模式在实际开发中常用于需要频繁创建相似对象的场景，尤其是在对象初始化代价较大的情况下。

15-请简述Java中原型模式的使用方式？

原型模式（Prototype Pattern）是一种创建型设计模式，它允许一个对象通过克隆已有对象来创建新对象，而不需要直接实例化类。这种方式可以简化对象的创建过程，特别是当对象的创建较为复杂时。

在Java中实现原型模式通常涉及以下步骤：

1. 定义一个接口或抽象类
   该接口或抽象类需要包含一个用于克隆的方法，通常命名为clone()。这个方法应该返回一个与当前对象相同类型的对象。

2. 实现Cloneable接口
   为了能够使用clone()方法，类必须实现Cloneable接口。Cloneable是一个标记接口，没有方法定义，但它表明该类支持复制操作。

3. 重写clone()方法
   默认情况下，Object类提供了一个受保护的clone()方法。你需要将其重写为公共方法，并处理浅拷贝和深拷贝的问题。

4. 客户端代码调用clone()
   客户端可以通过调用已知对象的clone()方法来获取新对象。

---

示例代码

下面是一个简单的示例，展示了如何在Java中实现原型模式：

// 定义一个实现了 Cloneable 接口的类
class Prototype implements Cloneable {
    private String attribute;

    public Prototype(String attribute) {
        this.attribute = attribute;
    }

    // 重写 clone() 方法
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone(); // 使用默认的浅拷贝
    }

    // Getter 和 Setter 方法
    public String getAttribute() {
        return attribute;
    }

    public void setAttribute(String attribute) {
        this.attribute = attribute;
    }
}

public class PrototypePatternDemo {
    public static void main(String[] args) {
        try {
            // 创建原始对象
            Prototype original = new Prototype("Original Value");
            System.out.println("Original Attribute: " + original.getAttribute());

            // 克隆对象
            Prototype cloned = (Prototype) original.clone();
            System.out.println("Cloned Attribute: " + cloned.getAttribute());

            // 修改克隆对象的属性
            cloned.setAttribute("Modified Value in Cloned Object");
            System.out.println("After modification:");
            System.out.println("Original Attribute: " + original.getAttribute());
            System.out.println("Cloned Attribute: " + cloned.getAttribute());
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}

---

浅拷贝与深拷贝

• 浅拷贝：只复制对象的基本数据类型字段和引用类型字段的引用。如果原对象包含其他对象的引用，则浅拷贝不会复制这些对象本身，而是共享同一个引用。

• 深拷贝：不仅复制对象本身，还会递归地复制所有引用的对象，确保新对象与其副本之间没有任何依赖关系。

在实际应用中，选择浅拷贝还是深拷贝取决于具体需求。对于复杂的对象结构，可能需要实现深拷贝以避免不必要的副作用。

---

注意事项

• Cloneable接口本身并没有定义任何方法，但它表示该类是可克隆的。如果类没有实现Cloneable接口却调用了clone()方法，将会抛出CloneNotSupportedException异常。

• 如果类中包含不可变对象或基本数据类型，浅拷贝通常就足够了；但对于可变对象，通常需要实现深拷贝。

通过上述方式，你可以有效地利用原型模式在Java中简化对象的创建过程。

16-简述什么是观察者模式？

观察者模式（Observer Pattern）是一种设计模式，它定义了一种一对多的依赖关系，使得多个观察者对象能够同时监听某一个主题对象。当主题对象的状态发生变化时，它的所有依赖者（即观察者）都会收到通知，并自动更新自己。

主要角色：

1. 主题（Subject）：也称为被观察者，它是观察的目标。它负责维护一个观察者列表，并提供添加、删除观察者的接口，以及通知所有观察者的方法。
2. 观察者（Observer）：也称为订阅者，它定义了一个更新接口，当主题的状态发生变化时，会调用这个接口进行相应的处理。
3. 具体主题（ConcreteSubject）：实现了主题接口的具体类，它包含具体的业务逻辑，当状态改变时，会通知所有的观察者。
4. 具体观察者（ConcreteObserver）：实现了观察者接口的具体类，它保存了一个指向具体主题对象的引用，以便在接收到通知后获取主题的状态信息并作出相应反应。

优点：

• 松耦合：观察者和主题之间是松耦合的，观察者不需要知道主题的具体实现，只需要关注状态变化即可。
• 支持广播通信：主题可以向所有注册的观察者广播通知，而不需要关心谁是观察者。
• 灵活性高：可以动态地增加或删除观察者，而不会影响主题和其他观察者。

缺点：

• 如果观察者数量过多，可能会导致性能问题，因为每次通知都需要遍历所有观察者。
• 观察者之间的依赖关系复杂时，可能会引发连锁更新，导致难以调试的问题。

应用场景：

• 用户界面更新：例如，当数据模型发生变化时，UI组件需要同步更新。
• 订阅-发布系统：如消息队列、事件驱动系统等。
• 日志记录、缓存更新等场景。

总之，观察者模式适用于需要在对象状态变化时通知其他对象的场景，尤其是在多个对象之间存在依赖关系的情况下。

17- 请列举观察者模式应用场景？

观察者模式（Observer Pattern）是一种设计模式，它定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。当主题对象发生变化时，它的所有依赖者（观察者）都会收到通知并自动更新。以下是观察者模式的一些典型应用场景：

1. 图形用户界面事件处理：

   • 在GUI编程中，按钮、文本框等组件的状态变化需要通知其他组件或逻辑模块。例如，当用户点击按钮时，系统会通知相关的处理器进行相应的操作。

2. 消息订阅和发布系统：

   • 类似于新闻网站或RSS订阅服务，用户可以订阅感兴趣的主题或频道，一旦有新的内容发布，订阅者就会立即收到通知。

3. 数据绑定机制：

   • 在现代Web框架（如Angular、Vue.js）或桌面应用开发中，视图与模型之间的双向数据绑定就是观察者模式的应用。当模型数据发生改变时，视图会自动更新以反映最新的状态。

4. 缓存同步：

   • 当缓存中的数据被修改后，需要通知所有使用该缓存数据的地方重新加载最新版本的数据。

5. 日志记录系统：

   • 系统运行过程中产生的日志信息可以通过观察者模式分发给不同的日志处理器，比如文件日志、数据库日志、网络日志等。

6. 库存管理系统：

   • 商品数量的变化（增加/减少）可能会影响多个业务流程，如销售订单处理、采购建议生成等。这些业务流程可以作为观察者来响应库存变化的通知。

7. 游戏开发中的状态变化通知：

   • 游戏角色的生命值、经验值等属性发生变化时，可以触发一系列后续动作，如UI更新、音效播放等。

8. 金融交易平台：

   • 股票价格波动时，需要及时通知投资者或执行自动化交易策略。这种情况下，股票价格可以看作是主题，而投资者或策略算法则是观察者。

9. 物联网设备管理平台：

   • 设备状态（在线/离线、故障报警等）发生改变时，平台需要向相关用户或维护人员发送警报信息。

通过使用观察者模式，可以使代码更加解耦合，提高系统的灵活性和可维护性。每个观察者只关心自己感兴趣的事件，不需要了解其他观察者的存在，从而简化了复杂系统的构建。

18 - 请 Java 代码实现观察者模式的案例？

观察者模式简介

观察者模式（Observer Pattern）是一种行为设计模式，它定义了一种一对多的依赖关系，当一个对象的状态发生变化时，所有依赖于它的对象都会自动得到通知并更新。通常适用于以下场景：

• 当一个对象的状态改变需要其他对象同步更新时。
• 当一个对象必须在不知道具体类的情况下与其他对象交互时。

Java 中可以使用 Observer 和 Observable 接口来实现观察者模式，也可以通过自定义接口和类来实现更灵活的设计。

自定义观察者模式案例

我们将通过一个简单的天气预报系统来演示观察者模式。假设我们有一个 WeatherData 类作为被观察者（Subject），多个显示设备（如 CurrentConditionsDisplay，StatisticsDisplay）作为观察者（Observer）。每当天气数据变化时，所有的观察者会自动更新。

1. 定义 Observer 接口

public interface Observer {
    void update(float temperature, float humidity, float pressure);
}

2. 定义 Subject 接口

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

public interface Subject {
    void registerObserver(Observer o);
    void removeObserver(Observer o);
    void notifyObservers();
}

3. 实现 WeatherData 类（被观察者）

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

public class WeatherData implements Subject {
    private List<Observer> observers;
    private float temperature;
    private float humidity;
    private float pressure;

    public WeatherData() {
        observers = new ArrayList<>();
    }

    @Override
    public void registerObserver(Observer o) {
        observers.add(o);
    }

    @Override
    public void removeObserver(Observer o) {
        observers.remove(o);
    }

    @Override
    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update(temperature, humidity, pressure);
        }
    }

    // 模拟天气数据变化
    public void setMeasurements(float temperature, float humidity, float pressure) {
        this.temperature = temperature;
        this.humidity = humidity;
        this.pressure = pressure;
        measurementsChanged();
    }

    private void measurementsChanged() {
        notifyObservers();
    }
}

4. 实现 CurrentConditionsDisplay 类（观察者）

public class CurrentConditionsDisplay implements Observer {
    private float temperature;
    private float humidity;
    private Subject weatherData;

    public CurrentConditionsDisplay(Subject weatherData) {
        this.weatherData = weatherData;
        weatherData.registerObserver(this);
    }

    @Override
    public void update(float temperature, float humidity, float pressure) {
        this.temperature = temperature;
        this.humidity = humidity;
        display();
    }

    public void display() {
        System.out.println("Current conditions: " + temperature + "F degrees and " + humidity + "% humidity");
    }
}

5. 实现 StatisticsDisplay 类（观察者）

public class StatisticsDisplay implements Observer {
    private float maxTemp = 0.0f;
    private float minTemp = 200;
    private float tempSum = 0.0f;
    private int numReadings;
    private Subject weatherData;

    public StatisticsDisplay(Subject weatherData) {
        this.weatherData = weatherData;
        weatherData.registerObserver(this);
    }

    @Override
    public void update(float temperature, float humidity, float pressure) {
        tempSum += temperature;
        numReadings++;
        if (temperature > maxTemp) {
            maxTemp = temperature;
        }
        if (temperature < minTemp) {
            minTemp = temperature;
        }
        display();
    }

    public void display() {
        System.out.println("Avg/Max/Min temperature = " + (tempSum / numReadings)
                + "/" + maxTemp + "/" + minTemp);
    }
}

6. 测试代码

public class WeatherStation {
    public static void main(String[] args) {
        WeatherData weatherData = new WeatherData();
        CurrentConditionsDisplay currentDisplay = new CurrentConditionsDisplay(weatherData);
        StatisticsDisplay statisticsDisplay = new StatisticsDisplay(weatherData);

        // 模拟天气数据变化
        weatherData.setMeasurements(80, 65, 30.4f);
        weatherData.setMeasurements(82, 70, 29.2f);
        weatherData.setMeasurements(78, 90, 29.2f);
    }
}

运行结果

Current conditions: 80.0F degrees and 65.0% humidity
Avg/Max/Min temperature = 80.0

19-简述什么是装饰模式？

装饰模式（Decorator Pattern）是一种结构型设计模式，它允许你通过将对象放入包含行为的特殊封装对象中来为原对象绑定新的行为。装饰模式可以在不改变原对象的前提下动态地给对象添加职责或功能。

主要特点：

1. 动态扩展：可以在运行时动态地添加功能，而不需要修改原来的类。
2. 灵活性：相比于继承，装饰模式提供了更灵活的方式来组合功能。
3. 遵循开闭原则：在不修改现有代码的情况下，可以对系统进行扩展。

类型：

• 类装饰器：通常用于修饰类本身，可以为类添加静态方法、属性等。
• 函数装饰器：用于修饰函数或方法，可以在调用前后执行额外的操作。

应用场景：

• 当需要给某个对象增加功能，但又不想使用继承的方式时。
• 当需要根据不同的需求动态地为对象添加不同的行为时。

例子：

假设有一个 Coffee 类表示基础咖啡，而我们希望可以动态地为咖啡添加糖、奶精等功能。通过装饰模式，我们可以创建 SugarDecorator 和 MilkDecorator 来包裹原始的 Coffee 对象，并在需要的时候动态地添加这些功能。

总结：

装饰模式提供了一种比继承更灵活的方式来扩展对象的功能，同时保持了代码的简洁性和可维护性。

20. 请Java代码实现装饰者模式的案例

装饰者模式（Decorator Pattern）是一种结构型设计模式，它允许你动态地为对象添加行为或职责，而无需修改其原始类。它通过创建一个包装对象（即装饰器）来包裹真实对象，并在需要时添加新的功能。

下面是一个使用Java实现的装饰者模式的案例，以咖啡店点餐系统为例：

1. 定义接口

首先，定义一个表示饮料的接口 Beverage，所有的饮料类都需要实现这个接口。

public abstract class Beverage {
    String description = "Unknown Beverage";

    public String getDescription() {
        return description;
    }

    public abstract double cost();
}

2. 实现具体的饮料类

接下来，实现几种具体的饮料类，如 Espresso 和 HouseBlend。

public class Espresso extends Beverage {
    public Espresso() {
        description = "Espresso";
    }

    @Override
    public double cost() {
        return 1.99;
    }
}

public class HouseBlend extends Beverage {
    public HouseBlend() {
        description = "House Blend Coffee";
    }

    @Override
    public double cost() {
        return 0.89;
    }
}

3. 定义装饰者基类

然后，定义一个抽象的装饰者类 CondimentDecorator，它也实现了 Beverage 接口，并持有一个 Beverage 类型的对象引用。

public abstract class CondimentDecorator extends Beverage {
    public abstract String getDescription();
}

4. 实现具体的装饰者类

接下来，实现一些具体的装饰者类，比如 Mocha 和 Whip，它们可以为饮料添加额外的功能。

public class Mocha extends CondimentDecorator {
    Beverage beverage;

    public Mocha(Beverage beverage) {
        this.beverage = beverage;
    }

    @Override
    public String getDescription() {
        return beverage.getDescription() + ", Mocha";
    }

    @Override
    public double cost() {
        return beverage.cost() + 0.20;
    }
}

public class Whip extends CondimentDecorator {
    Beverage beverage;

    public Whip(Beverage beverage) {
        this.beverage = beverage;
    }

    @Override
    public String getDescription() {
        return beverage.getDescription() + ", Whip";
    }

    @Override
    public double cost() {
        return beverage.cost() + 0.50;
    }
}

5. 测试装饰者模式

最后，编写一个测试类来验证装饰者模式的效果。

public class StarbuzzCoffee {
    public static void main(String[] args) {
        // 创建一个简单的Espresso
        Beverage beverage = new Espresso();
        System.out.println(beverage.getDescription() + " $" + beverage.cost());

        // 创建一个HouseBlend并添加Mocha和Whip
        Beverage beverage2 = new HouseBlend();
        beverage2 = new Mocha(beverage2);
        beverage2 = new Whip(beverage2);
        System.out.println(beverage2.getDescription() + " $" + beverage2.cost());
    }
}

输出结果：

Espresso $1.99
House Blend Coffee, Mocha, Whip $1.59

在这个例子中，我们通过装饰者模式动态地为饮料添加了不同的调料（如摩卡和奶泡），并且可以在不改变原有类的情况下灵活地组合这些功能。

21- 简述Java什么是适配器模式

适配器模式（Adapter Pattern）是Java中一种结构型设计模式。它主要解决的是接口不兼容的问题，允许原本由于接口不匹配而无法一起工作的类可以协同工作。适配器模式就像是一个转换器，将一个类的接口转换成另一个类期望的接口。

适配器模式有两种主要实现方式：

1. 类适配器：通过继承目标接口并实现源类的功能来创建适配器。这种方式要求语言支持多继承（如C++），但在Java中只能单继承类，因此通常不太适用。
2. 对象适配器：通过组合的方式，即在适配器类中包含一个源类的对象实例，并通过委托调用其方法。这是Java中最常用的实现方式。

适配器模式的基本要素：

• 目标接口（Target Interface）：定义客户端使用的接口。
• 适配者（Adaptee）：需要被适配的类，拥有不同的接口。
• 适配器（Adapter）：负责将适配者的接口转换为目标接口，使二者能够兼容。

示例场景：

假设你有一个旧系统的类 OldSystemClass，它的方法签名与新系统的需求不一致。你可以编写一个适配器类 SystemAdapter，它实现了新系统期望的接口，并在其内部使用 OldSystemClass 的实例完成实际操作。这样新系统就可以直接调用适配器提供的接口，而不需要关心底层的具体实现。

适配器模式广泛应用于各种框架和库中，尤其是在需要集成第三方组件或处理遗留代码时非常有用。

22 - 请Java代码实现适配器模式的案例

适配器模式（Adapter Pattern）是结构型设计模式之一，它允许不兼容的接口一起工作。适配器充当两个类之间的桥梁。它通常用于使现有的类适用于新的接口或类。

案例背景

假设我们有一个老系统的 AudioPlayer 类，它只能播放 MP3 格式的音频文件。现在我们需要扩展它的功能，使其能够播放其他格式的音频文件，比如 VLC 和 MP4。为了实现这一点，我们可以使用适配器模式。

代码实现

1. 定义目标接口：这是新系统希望使用的接口。
2. 定义适配者类：这是已有系统的类，具有不同的接口。
3. 创建适配器类：将适配者类的接口转换为目标接口。
4. 客户端代码：使用适配器来调用适配者的方法。

// 目标接口：MediaPlayer
interface MediaPlayer {
    void play(String audioType, String fileName);
}

// 适配者类：AdvancedMediaPlayer
class AdvancedMediaPlayer {
    public void playVlc(String fileName) {
        System.out.println("Playing VLC file. Name: " + fileName);
    }

    public void playMp4(String fileName) {
        System.out.println("Playing MP4 file. Name: " + fileName);
    }
}

// 适配器类：MediaAdapter
class MediaAdapter implements MediaPlayer {
    private AdvancedMediaPlayer advancedMediaPlayer;

    public MediaAdapter(String audioType) {
        if (audioType.equalsIgnoreCase("vlc")) {
            advancedMediaPlayer = new AdvancedMediaPlayer();
        } else if (audioType.equalsIgnoreCase("mp4")) {
            advancedMediaPlayer = new AdvancedMediaPlayer();
        }
    }

    @Override
    public void play(String audioType, String fileName) {
        if (audioType.equalsIgnoreCase("vlc")) {
            advancedMediaPlayer.playVlc(fileName);
        } else if (audioType.equalsIgnoreCase("mp4")) {
            advancedMediaPlayer.playMp4(fileName);
        } else {
            System.out.println("Invalid media. " + audioType + " format not supported");
        }
    }
}

// 原有系统类：AudioPlayer
class AudioPlayer implements MediaPlayer {
    MediaAdapter mediaAdapter;

    @Override
    public void play(String audioType, String fileName) {
        // 内置支持 MP3 播放
        if (audioType.equalsIgnoreCase("mp3")) {
            System.out.println("Playing MP3 file. Name: " + fileName);
        } else if (audioType.equalsIgnoreCase("vlc") || audioType.equalsIgnoreCase("mp4")) {
            mediaAdapter = new MediaAdapter(audioType);
            mediaAdapter.play(audioType, fileName);
        } else {
            System.out.println("Invalid media. " + audioType + " format not supported");
        }
    }
}

// 客户端代码
public class AdapterPatternDemo {
    public static void main(String[] args) {
        AudioPlayer audioPlayer = new AudioPlayer();
        
        // 原生支持 MP3
        audioPlayer.play("mp3", "beyond_the_horizon.mp3");
        
        // 使用适配器播放 VLC
        audioPlayer.play("vlc", "alone.vlc");
        
        // 使用适配器播放 MP4
        audioPlayer.play("mp4", "far far away.mp4");
    }
}

运行结果

Playing MP3 file. Name: beyond_the_horizon.mp3
Playing VLC file. Name: alone.vlc
Playing MP4 file. Name: far far away.mp4

解释：

• MediaPlayer 是目标接口，表示所有音频播放器都应实现的方法。
• AdvancedMediaPlayer 是适配者类，它具有播放不同格式音频文件的功能。
• MediaAdapter 是适配器类，它实现了 MediaPlayer 接口，并根据音频类型调用 AdvancedMediaPlayer 的方法。
• AudioPlayer 是原有系统中的类，它通过适配器扩展了对新音频格式的支持。

通过适配器模式，我们可以在不修改原有代码的情况下，扩展系统的功能。