设计模式之工厂模式(通俗易懂--代码辅助理解【Java版】）

文章目录

1、工厂模式概述
2、简单工厂模式(静态工厂模式)
- 1) 在简单工厂模式中，有三个主要角色：在简单工厂模式中，有三个主要角色：)
- 2) 简单工厂模式的优点包括：简单工厂模式的优点包括：)
- 3) 简单工厂模式也有一些限制和考虑因素：简单工厂模式也有一些限制和考虑因素：)
- 4) 简单工厂模式适用场景：简单工厂模式适用场景：)
- 5) 简单工厂UML类图：简单工厂UML类图：)
- 6) 代码示例：代码示例：)
3、工厂方法模式
- 1) 在工厂方法模式中，有4个主要角色：在工厂方法模式中，有4个主要角色：)
- 2) 工厂方法模式的工作流程：工厂方法模式的工作流程：)
- 3) 工厂方法模式适用场景：工厂方法模式适用场景：)
- 4) 工厂方法模式UML类图：工厂方法模式UML类图：)
- 5) 代码示例：代码示例：)
4、抽象工厂模式
- 1) 在抽象工厂模式中，有4个主要角色：在抽象工厂模式中，有4个主要角色：)
- 2) 抽象工厂模式的工作流程：抽象工厂模式的工作流程：)
- 3) 抽象工厂模式的优点：抽象工厂模式的优点：)
- 4) 抽象工厂模式的缺点：抽象工厂模式的缺点：)
- 5) 抽象工厂模式适用场景：抽象工厂模式适用场景：)
- 6) 抽象工厂模式UML类图：抽象工厂模式UML类图：)
- 7) 代码示例：代码示例：)

1、工厂模式概述

1）特点：

工厂模式（Factory Pattern）是一种创建型设计模式，旨在提供一种统一的方式来创建对象，将对象的实例化过程封装在一个单独的类中。工厂模式通过定义一个公共的接口来创建对象，但允许子类决定实例化哪个类。这样可以将对象的实例化与客户端代码的耦合度降到最低，同时也提供了一种可扩展的方式来创建对象。

2）主要角色：

抽象产品：定义产品的通用接口，具体产品类需要实现该接口。
具体产品：实现抽象产品接口的类，代表实际的产品。
抽象工厂：定义创建产品的接口，可以是抽象类或接口，声明工厂方法。
具体工厂：实现抽象工厂的接口，负责创建具体产品对象。

3）工作流程：

客户端通过抽象工厂请求产品实例。
具体工厂类根据请求创建并返回对应的具体产品。
客户端使用产品实例，而不直接依赖具体产品类。

4）优点

解耦：将对象的创建与使用分离，降低了客户端与具体产品的耦合度。
易扩展：可以通过新增具体产品和工厂，轻松扩展系统而无需修改现有代码。
灵活性：可以动态替换产品实例，提供灵活的对象创建方式。

5）缺点

系统复杂性增加：引入了多个类和接口，增加了系统的复杂度。
代码量增加：添加新产品时，需要创建新的具体产品类和对应的具体工厂类。
类的爆炸性增长：随着产品族增加，具体工厂类的数量可能大幅增长。

6）适用场景

需要统一管理对象创建过程的场景。
系统需要频繁扩展和替换产品类的场景。

2、简单工厂模式(静态工厂模式)

简单工厂模式(Simple Factory Pattern) 是工厂模式的一种简化形式，也被称为静态工厂模式。它通过一个专门的工厂类来创建对象，而无需将对象的实例化过程放在客户端代码中。

1) 在简单工厂模式中，有三个主要角色：

抽象产品（Abstract Product）：定义产品的通用接口，所有具体产品类都应该实现这个接口。
具体产品（Concrete Product）：实现抽象产品接口的具体类。
简单工厂（Simple Factory） ：负责创建具体产品的工厂类。它通常包含一个静态方法，根据客户端的请求来创建并返回具体产品的实例。

2) 简单工厂模式的优点包括：

将对象的创建过程集中在一个工厂类中，减少了客户端代码与具体产品的直接耦合。
可以通过简单工厂类的静态方法来创建产品，简化了客户端的调用代码。
可以轻松添加新的产品，只需修改简单工厂类的创建方法，而无需修改客户端代码。

3) 简单工厂模式也有一些限制和考虑因素：

工厂类负责创建所有产品，当产品种类较多时，工厂类的代码可能会变得复杂。
添加新产品时，需要修改工厂类的代码，违反了开闭原则。

4) 简单工厂模式适用场景：

简单工厂模式适用于需要根据客户端请求来创建不同类型对象的场景，但产品种类较少且不经常变化的情况。它提供了一种简单的方式来封装对象的创建过程，降低了客户端代码与具体产品的耦合度。

5) 简单工厂UML类图：

6) 代码示例：

java 复制代码

// 抽象产品类
abstract class Product {
    public abstract void use();
}

// 具体产品类A
class ConcreteProductA extends Product {
    @Override
    public void use() {
        System.out.println("Using ConcreteProductA");
    }
}

// 具体产品类B
class ConcreteProductB extends Product {
    @Override
    public void use() {
        System.out.println("Using ConcreteProductB");
    }
}

// 简单工厂类
class SimpleFactory {
    public Product createProduct(String type) {
        if (type.equals("A")) {
            return new ConcreteProductA();
        } else if (type.equals("B")) {
            return new ConcreteProductB();
        } else {
            // 处理未知产品类型的情况
            return null;
        }
    }
}

public class Main {
    public static void main(String[] args) {
        // 使用简单工厂创建产品
        SimpleFactory factory = new SimpleFactory();

        Product productA = factory.createProduct("A");
        if (productA != null) {
            productA.use();
        }

        Product productB = factory.createProduct("B");
        if (productB != null) {
            productB.use();
        }

        Product unknownProduct = factory.createProduct("C");
        if (unknownProduct == null) {
            System.out.println("Unknown product type.");
        }
    }
}

3、工厂方法模式

工厂方法模式（Factory Method Pattern） 是一种创建型设计模式，它提供了一种将对象的创建委托给子类的方式。在工厂方法模式中，定义一个用于创建对象的接口，但让子类决定实例化哪个类。这样可以将对象的创建与使用解耦，使得系统在不修改具体产品类的情况下可以引入新的产品。

1) 在工厂方法模式中，有4个主要角色：

抽象产品（Abstract Product）：定义产品的通用接口，所有具体产品类都应该实现这个接口。
具体产品（Concrete Product）：实现抽象产品接口的具体类，是工厂方法模式所创建的对象。
抽象工厂（Factory）：定义了工厂方法的接口，负责创建抽象产品的对象。
具体工厂（Concrete Factory）：实现了抽象工厂接口，具体工厂类根据具体业务逻辑，创建具体产品的对象。

2) 工厂方法模式的工作流程：

客户端通过调用具体工厂类的工厂方法来创建产品对象。
具体工厂类根据客户端的请求，调用具体产品类的构造方法创建具体产品对象。
具体工厂类将创建的具体产品对象返回给客户端。

通过工厂方法模式，客户端与具体产品类解耦，客户端只需关心抽象产品和抽象工厂，具体产品的创建由具体工厂类来完成。这样，当需要引入新的产品时，只需创建一个新的具体产品类和对应的具体工厂类，而不需要修改客户端代码。

3) 工厂方法模式适用场景：

当一个类无法预知它需要创建的对象的具体类时，可以使用工厂方法模式。
当一个类希望将对象的创建责任委托给多个子类中的某一个时，可以使用工厂方法模式。
当一个类需要通过其子类来指定创建对象时，可以使用工厂方法模式。

总结来说，工厂方法模式通过定义一个创建对象的接口，将对象的实例化延迟到子类中去完成，实现了对象的创建与使用的解耦，提高了系统的可扩展性和灵活性。

4) 工厂方法模式UML类图：

5) 代码示例：

java 复制代码

// 抽象产品类
abstract class Product {
    // 抽象方法
    public abstract void use();
}

// 具体产品类A
class ConcreteProductA extends Product {
    @Override
    public void use() {
        System.out.println("Using ConcreteProductA");
    }
}

// 具体产品类B
class ConcreteProductB extends Product {
    @Override
    public void use() {
        System.out.println("Using ConcreteProductB");
    }
}

// 抽象工厂类
abstract class Factory {
    // 抽象工厂方法
    public abstract Product createProduct();

    // 打印产品使用信息
    public void print() {
        Product product = createProduct();
        product.use();
    }
}

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

// 具体工厂类B
class ConcreteFactoryB extends Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductB();
    }
}

public class Main {
    public static void main(String[] args) {
        // 使用工厂类创建产品
        Factory factoryA = new ConcreteFactoryA();
        factoryA.print();

        Factory factoryB = new ConcreteFactoryB();
        factoryB.print();
    }
}

运行结果
Using ConcreteProductA
Using ConcreteProductB

4、抽象工厂模式

抽象工厂模式（Abstract Factory Pattern） 是一种创建型设计模式，旨在提供一种统一的方式来创建一系列相关或相互依赖的对象 ，而无需指定具体的类。它通过定义一个抽象工厂接口和一组具体工厂类，来创建一族产品对象。

1) 在抽象工厂模式中，有4个主要角色：

抽象工厂（Abstract Product）：定义了创建一族产品对象的接口。它通常包含一组用于创建不同产品的工厂方法。
具体工厂（Concrete Product）：实现了抽象工厂接口，负责创建具体的产品对象。
抽象产品（Factory）：定义了一族产品对象的通用接口。具体产品类应实现这个接口。
具体产品（Concrete Factory）：实现了抽象产品接口，是由具体工厂创建的对象。

2) 抽象工厂模式的工作流程：

客户端通过抽象工厂接口来创建一族相关的产品对象。
具体工厂类实现了抽象工厂接口，负责创建具体的产品对象。
抽象工厂的工厂方法根据具体工厂的实现，创建并返回具体产品的实例。
客户端使用返回的产品实例进行操作，而无需关心具体产品的实现细节。

3) 抽象工厂模式的优点：

将对象的创建和使用分离，降低了客户端代码与具体产品的耦合度。
提供了一种可替换的方式来创建一族相关产品，使得系统更加灵活和可维护。
符合开闭原则，可以轻松添加新的具体工厂和产品类，扩展系统功能。

4) 抽象工厂模式的缺点：

当产品族的数量增加时，抽象工厂和具体工厂的接口可能变得复杂，需要谨慎设计和管理。
添加新的产品族可能需要修改抽象工厂和所有具体工厂的代码，违反了开闭原则。

5) 抽象工厂模式适用场景：

抽象工厂模式适用于需要创建一族相关产品对象的场景，其中产品之间存在一定的关联或依赖关系。它提供了一种统一的方式来管理产品的创建过程，将对象的创建与客户端代码解耦，同时也支持动态替换和扩展对象的创建。

6) 抽象工厂模式UML类图：

7) 代码示例：

java 复制代码

// 抽象产品A
interface AbstractProductA {
    void use();
}

// 具体产品A1
class ConcreteProductA1 implements AbstractProductA {
    @Override
    public void use() {
        System.out.println("Using ConcreteProductA1");
    }
}

// 具体产品A2
class ConcreteProductA2 implements AbstractProductA {
    @Override
    public void use() {
        System.out.println("Using ConcreteProductA2");
    }
}

// 抽象产品B
interface AbstractProductB {
    void eat();
}

// 具体产品B1
class ConcreteProductB1 implements AbstractProductB {
    @Override
    public void eat() {
        System.out.println("Eating ConcreteProductB1");
    }
}

// 具体产品B2
class ConcreteProductB2 implements AbstractProductB {
    @Override
    public void eat() {
        System.out.println("Eating ConcreteProductB2");
    }
}

// 抽象工厂
interface AbstractFactory {
    AbstractProductA createProductA();
    AbstractProductB createProductB();
}

// 具体工厂1
class ConcreteFactory1 implements AbstractFactory {
    @Override
    public AbstractProductA createProductA() {
        return new ConcreteProductA1();
    }

    @Override
    public AbstractProductB createProductB() {
        return new ConcreteProductB1();
    }
}

// 具体工厂2
class ConcreteFactory2 implements AbstractFactory {
    @Override
    public AbstractProductA createProductA() {
        return new ConcreteProductA2();
    }

    @Override
    public AbstractProductB createProductB() {
        return new ConcreteProductB2();
    }
}

// 主程序
public class Main {
    public static void main(String[] args) {
        // 使用具体工厂1创建产品族1
        AbstractFactory factory1 = new ConcreteFactory1();
        AbstractProductA productA1 = factory1.createProductA();
        AbstractProductB productB1 = factory1.createProductB();

        productA1.use();
        productB1.eat();

        // 使用具体工厂2创建产品族2
        AbstractFactory factory2 = new ConcreteFactory2();
        AbstractProductA productA2 = factory2.createProductA();
        AbstractProductB productB2 = factory2.createProductB();

        productA2.use();
        productB2.eat();
    }
}

运行结果
Using ConcreteProductA1
Eating ConcreteProductB1
Using ConcreteProductA2
Eating ConcreteProductB2