Java 面试八股文2023：设计模式概述与常见应用

# 1. 设计模式基础概念

## 1.1 设计模式简介

设计模式是在软件开发过程中对一类常见问题的通用解决方案。它是解决软件设计中常见问题的最佳实践经验的总结，是经验的提炼和抽象。设计模式提供了一套通用的设计方案，帮助我们更好地应对变化、提高代码质量、增加代码的可重用性和可维护性。

## 1.2 为什么要使用设计模式

- 提高代码的重用性：设计模式可帮助我们避免重复编写相同的代码
- 提高代码的可维护性：设计模式提供了良好的代码组织结构，使代码的可读性更强
- 降低代码的耦合性：通过设计模式，不同的部分之间的依赖关系更加清晰
- 促进代码的扩展性：设计模式可以使系统更容易扩展新功能

## 1.3 设计模式的分类

设计模式一般分为三种主要类型：

- **创建型设计模式**：用于处理对象的创建机制，包括单例模式、工厂模式、抽象工厂模式等
- **结构型设计模式**：处理对象之间的组合，包括适配器模式、装饰器模式、代理模式等
- **行为型设计模式**：描述对象间的协作和职责分配，包括观察者模式、策略模式、模板方法模式等

通过以上概述，我们对设计模式的基础概念有了一定的了解。接下来，我们将深入探讨各种设计模式的具体应用及重要性。

# 2. 创建型设计模式

### 2.1 单例模式
- **定义**：确保一个类只有一个实例，并提供全局访问点。
- **应用场景**：需要全局访问点的场景，如配置信息、日志记录等。

#### 单例模式示例代码（Java）：

public class Singleton {
    private static Singleton instance;

    private Singleton() {}

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

- **优点**：
- 节省内存资源，避免多次创建对象。
- 确保全局访问点，方便统一管理。

- **缺点**：
- 可能会引起多线程安全问题。
### 2.2 工厂模式
- **定义**：定义一个创建对象的接口，让子类决定实例化哪个类。
- **应用场景**：需要统一创建对象的场景，根据不同需求创建不同的实例。

#### 工厂模式示例代码（Java）：

// 抽象产品
interface Product {
    void show();
}

// 具体产品A
class ConcreteProductA implements Product {
    public void show() {
        System.out.println("This is product A.");
    }
}

// 工厂
class Factory {
    public Product createProduct(String type) {
        if ("A".equals(type)) {
            return new ConcreteProductA();
        }
        return null;
    }
}

- **优点**：
- 遵循开闭原则，新增产品无需修改现有代码。
- 将对象的创建和使用分离，降低耦合度。

- **缺点**：
- 增加了类的数量，增加了系统的复杂度。

#### 工厂模式流程图：

graph TD
    A[Client] -->|Request Product| B(Factory)
    B -->|Create Product| C{Product}
    C -->|Return Product| A

# 3. 结构型设计模式

结构型设计模式主要关注如何将类或对象结合在一起形成更大的结构，提供了一种简单的方法来实现对象组合。

### 3.1 适配器模式

适配器模式是一种结构型设计模式，用于允许不兼容接口的类之间协同工作。通过适配器，客户端可以与不同接口的类进行交互，而不需要改变其源代码。

在适配器模式中，有三个主要角色：
- 目标接口（Target）：定义客户端使用的特定接口。
- 适配器（Adapter）：实现目标接口，并包装一个被适配者的实例。
- 被适配者（Adaptee）：已存在的类，包含客户端希望使用的功能，但其接口与目标接口不兼容。

下面是适配器模式的Java示例代码：

// 目标接口
interface Target {
    void request();
}

// 被适配者
class Adaptee {
    public void specificRequest() {
        System.out.println("Adaptee's specific request");
    }
}

// 适配器
class Adapter implements Target {
    private Adaptee adaptee;

    public Adapter(Adaptee adaptee) {
        this.adaptee = adaptee;
    }

    @Override
    public void request() {
        adaptee.specificRequest();
    }
}

// 客户端代码
public class AdapterPatternExample {
    public static void main(String[] args) {
        Adaptee adaptee = new Adaptee();
        Target adapter = new Adapter(adaptee);

        adapter.request();
    }
}

### 3.2 装饰器模式

装饰器模式是一种结构型设计模式，允许向一个现有对象添加新功能，同时又不改变其结构。这种模式创建了一个装饰类，用于包装原有类，并提供额外的功能。

在装饰器模式中，有四个主要角色：
- 抽象构件（Component）：定义了原始对象和装饰对象的公共接口。
- 具体构件（ConcreteComponent）：实现了抽象构件接口，是被装饰的原始对象。
- 抽象装饰器（Decorator）：继承了抽象构件，并包含了一个指向抽象构件的引用。
- 具体装饰器（ConcreteDecorator）：继承自抽象装饰器，负责向构件添加新的功能。

下面是装饰器模式的Python示例代码：

# 抽象构件
class Component:
    def operation(self):
        pass

# 具体构件
class ConcreteComponent(Component):
    def operation(self):
        print("ConcreteComponent operation")

# 抽象装饰器
class Decorator(Component):
    def __init__(self, component):
        self.component = component

    def operation(self):
        self.component.operation()

# 具体装饰器
class ConcreteDecorator(Decorator):
    def operation(self):
        super().operation()
        print("Added new functionality")

# 客户端代码
component = ConcreteComponent()
decorator = ConcreteDecorator(component)
decorator.operation()

### 3.3 代理模式

代理模式是一种结构型设计模式，通过创建一个代理对象，代理可以控制对原始对象的访问。代理可以在访问原始对象前后进行一些额外的操作，如记录日志、权限验证等。

在代理模式中，有三个主要角色：
- 抽象主题（Subject）：定义了真实主题和代理的共同接口，客户端通过代理和真实主题交互。
- 真实主题（RealSubject）：实现了抽象主题接口，是客户端直接调用的对象。
- 代理