Java设计模式实战：从原理到应用，掌握设计模式精髓，提升代码可重用性和灵活性

.png)
# 1. Java设计模式概述**

设计模式是一种可重复使用的解决方案，用于解决软件设计中常见的编程问题。它们提供了经过验证的最佳实践，可帮助开发人员创建灵活、可维护和可扩展的代码。

Java设计模式被广泛应用于各种软件开发项目中，它们按其功能分为三大类：创建型、结构型和行为型。这些模式提供了一组预定义的模板，可帮助开发人员快速构建代码，同时保持代码的质量和可读性。

# 2. 创建型设计模式

创建型设计模式主要用于创建对象，它们提供了创建对象的不同方式，可以提高代码的灵活性、可重用性和可维护性。

### 2.1 工厂方法模式

#### 2.1.1 工厂方法模式的原理

工厂方法模式定义了一个创建对象的接口，但由子类决定要实例化的实际类。它允许类将创建对象的职责委托给其他对象，从而提高了代码的灵活性。

#### 2.1.2 工厂方法模式的应用场景

* 当需要创建不同类型的对象，但具体类型由子类决定时。
* 当需要将创建对象的职责与使用对象的职责分离时。

**代码示例：**

// 抽象工厂接口
interface Factory {
    Product createProduct();
}

// 具体工厂类
class ConcreteFactoryA implements Factory {
    @Override
    public Product createProduct() {
        return new ProductA();
    }
}

class ConcreteFactoryB implements Factory {
    @Override
    public Product createProduct() {
        return new ProductB();
    }
}

// 产品接口
interface Product {
    void doSomething();
}

// 具体产品类
class ProductA implements Product {
    @Override
    public void doSomething() {
        System.out.println("ProductA do something");
    }
}

class ProductB implements Product {
    @Override
    public void doSomething() {
        System.out.println("ProductB do something");
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Factory factoryA = new ConcreteFactoryA();
        Product productA = factoryA.createProduct();
        productA.doSomething();

        Factory factoryB = new ConcreteFactoryB();
        Product productB = factoryB.createProduct();
        productB.doSomething();
    }
}

**代码逻辑分析：**

* `Factory` 接口定义了创建产品的方法 `createProduct()`。
* `ConcreteFactoryA` 和 `ConcreteFactoryB` 是具体工厂类，实现了 `Factory` 接口，并创建了不同的产品。
* `Product` 接口定义了产品的方法 `doSomething()`。
* `ProductA` 和 `ProductB` 是具体产品类，实现了 `Product` 接口，并实现了不同的行为。
* `Client` 类是客户端代码，通过工厂创建不同的产品并调用其方法。

### 2.2 抽象工厂模式

#### 2.2.1 抽象工厂模式的原理

抽象工厂模式提供了一个接口，用于创建一系列相关的对象，而无需指定它们的具体类。它允许客户端在不依赖于具体产品类的情况下创建一组相关对象。

#### 2.2.2 抽象工厂模式的应用场景

* 当需要创建一系列相关对象，并且这些对象需要一起工作时。
* 当需要将创建对象的职责与使用对象的职责分离时。

**代码示例：**

// 抽象工厂接口
interface AbstractFactory {
    ProductA createProductA();
    ProductB createProductB();
}

// 具体工厂类
class ConcreteFactory1 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ProductA1();
    }

    @Override
    public ProductB createProductB() {
        return new ProductB1();
    }
}

class ConcreteFactory2 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ProductA2();
    }

    @Override
    public ProductB createProductB() {
        return new ProductB2();
    }
}

// 产品接口
interface ProductA {
    void doSomething();
}

// 具体产品类
class ProductA1 implements ProductA {
    @Override
    public void doSomething() {
        System.out.println("ProductA1 do somethi