工厂模式详解-CSDN博客

本文链接：https://blog.csdn.net/m0_47114547/article/details/136173226

文章目录

1.简单工厂模式

简单工厂模式（Simple Factory Pattern）并不是一种标准的设计模式（不在GoF设计模式的23种之列），而是一种编程习惯，用于创建对象而不必指定将要创建的对象的确切类。它有一个工厂类，可以根据参数的不同返回不同类的实例，被创建的实例通常都具有共同的父类和接口。

优点：将对象的创建和使用分离，客户端无需知道具体的实现类，只需要知道工厂类。
缺点：工厂类的职责相对过重，增加新的产品需要修改工厂类的判断逻辑，违反了开闭原则。

首先，定义一个接口或抽象类来规范产品对象的行为。

public interface Product {
    void use();
}

然后，实现具体的产品类。

public class ConcreteProductA implements Product {
    @Override
    public void use() {
        System.out.println("Using ConcreteProductA");
    }
}

public class ConcreteProductB implements Product {
    @Override
    public void use() {
        System.out.println("Using ConcreteProductB");
    }
}

接下来，创建一个工厂类来生成基于给定信息的具体产品对象。

public class SimpleFactory {
    public Product createProduct(String type) {
        switch (type) {
            case "A":
                return new ConcreteProductA();
            case "B":
                return new ConcreteProductB();
            default:
                throw new IllegalArgumentException("Unknown product type");
        }
    }
}

最后，客户端代码使用工厂类来创建产品对象。

public class Client {
    public static void main(String[] args) {
        SimpleFactory factory = new SimpleFactory();
        Product productA = factory.createProduct("A");
        productA.use();

        Product productB = factory.createProduct("B");
        productB.use();
    }
}

在这个例子中，SimpleFactory 类根据传入的参数（例如，类型"A"或"B"）决定实例化哪一个具体产品类（ConcreteProductA 或 ConcreteProductB）。客户端不需要直接实例化产品对象，而是通过工厂类来请求创建对象，这样就降低了客户端与具体产品类之间的耦合度。简单工厂模式适用于产品种类不太复杂，且不频繁添加新产品的情况。

2.工厂方法模式

工厂方法模式（Factory Method Pattern）是一种创建型设计模式，定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法让类的实例化推迟到子类中进行。

优点：在添加新的产品时不需要修改已有的工厂类，只需添加相应的产品类和具体工厂类即可，满足开闭原则。
缺点：每增加一个产品，就需要增加一个具体产品类和一个具体工厂类，增加了系统的复杂度。

在以下的例子中，将通过一个简单的日志记录器的例子来演示如何实现工厂方法模式。这个例子包括一个Logger接口和两个实现了这个接口的具体日志记录器类（FileLogger和ConsoleLogger），以及一个LoggerFactory接口和为每种日志记录器提供创建功能的具体工厂类。

首先，定义Logger接口和两个具体的日志记录器类：

// 日志记录器接口
public interface Logger {
    void log(String message);
}

// 将消息记录到控制台的具体日志记录器
public class ConsoleLogger implements Logger {
    public void log(String message) {
        System.out.println("ConsoleLogger: " + message);
    }
}

// 将消息记录到文件的具体日志记录器
public class FileLogger implements Logger {
    public void log(String message) {
        System.out.println("FileLogger: " + message);
    }
}

接下来，定义LoggerFactory接口和具体的工厂类：

// 日志记录器工厂接口
public interface LoggerFactory {
    Logger createLogger();
}

// 创建控制台日志记录器的工厂
public class ConsoleLoggerFactory implements LoggerFactory {
    public Logger createLogger() {
        // 创建一个新的控制台日志记录器实例
        return new ConsoleLogger();
    }
}

// 创建文件日志记录器的工厂
public class FileLoggerFactory implements LoggerFactory {
    public Logger createLogger() {
        // 创建一个新的文件日志记录器实例
        return new FileLogger();
    }
}

最后，客户端代码利用工厂来创建日志记录器：

public class Client {
    public static void main(String[] args) {
        LoggerFactory factory;
        Logger logger;

        // 使用控制台日志记录器
        factory = new ConsoleLoggerFactory();
        logger = factory.createLogger();
        logger.log("This is a message.");

        // 使用文件日志记录器
        factory = new FileLoggerFactory();
        logger = factory.createLogger();
        logger.log("This is another message.");
    }
}

在这个例子中，LoggerFactory定义了一个创建对象的方法createLogger，而具体的工厂类（ConsoleLoggerFactory和FileLoggerFactory）实现了这个方法来创建具体类型的日志记录器。这样，客户端代码就可以在不知道具体日志记录器类的情况下，通过工厂接口来创建日志记录器对象。这种方式使得添加新的日志记录器类型时，客户端代码不需要做任何修改，符合开闭原则。

3.抽象工厂模式

抽象工厂模式（Abstract Factory Pattern）是一种创建型设计模式，提供了一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。这种模式特别适用于那些系统中，有多个系列的产品需要创建，并且系统需要在多个系列产品之间切换时。该模式允许客户端使用抽象的接口来创建一组相关的产品，而不需要知道（或关心）具体产品的具体类。

优点：可以在类内部对产品族的相关对象进行组合，更易于交换产品系列，并保证其兼容性。
缺点：难以支持新种类的（产品），扩展新的产品族困难，需要修改抽象工厂的接口。

下面是一个简单的Java实现示例，假设有一个GUI元素的库，其中包括按钮和复选框，这些GUI元素有不同的风格（如Windows和Mac风格）。我们将使用抽象工厂模式来抽象和封装这些元素的创建过程。

首先，定义抽象产品接口和具体产品类：

// 抽象产品：按钮
public interface Button {
    void paint();
}

// 具体产品：Windows风格按钮
public class WindowsButton implements Button {
    public void paint() {
        System.out.println("Rendering a button in Windows style.");
    }
}

// 具体产品：Mac风格按钮
public class MacButton implements Button {
    public void paint() {
        System.out.println("Rendering a button in Mac style.");
    }
}

// 抽象产品：复选框
public interface Checkbox {
    void paint();
}

// 具体产品：Windows风格复选框
public class WindowsCheckbox implements Checkbox {
    public void paint() {
        System.out.println("Rendering a checkbox in Windows style.");
    }
}

// 具体产品：Mac风格复选框
public class MacCheckbox implements Checkbox {
    public void paint() {
        System.out.println("Rendering a checkbox in Mac style.");
    }
}

接下来，定义抽象工厂接口和具体工厂类：

// 抽象工厂
public interface GUIFactory {
    Button createButton();
    Checkbox createCheckbox();
}

// 具体工厂：Windows风格工厂
public class WindowsFactory implements GUIFactory {
    public Button createButton() {
        return new WindowsButton();
    }

    public Checkbox createCheckbox() {
        return new WindowsCheckbox();
    }
}

// 具体工厂：Mac风格工厂
public class MacFactory implements GUIFactory {
    public Button createButton() {
        return new MacButton();
    }

    public Checkbox createCheckbox() {
        return new MacCheckbox();
    }
}

最后，客户端代码可能看起来像这样：

public class Application {
    private Button button;
    private Checkbox checkbox;

    public Application(GUIFactory factory) {
        button = factory.createButton();
        checkbox = factory.createCheckbox();
    }

    public void paint() {
        button.paint();
        checkbox.paint();
    }

    public static void main(String[] args) {
        GUIFactory factory = new WindowsFactory();
        Application app = new Application(factory);
        app.paint();
        
        // 切换到Mac风格
        factory = new MacFactory();
        app = new Application(factory);
        app.paint();
    }
}

在这个例子中，Application类不直接依赖于具体的按钮或复选框类（如WindowsButton或MacCheckbox），而是通过GUIFactory接口来创建这些对象。这样，通过更换不同的GUIFactory实现（如WindowsFactory或MacFactory），就可以在不同的GUI风格之间切换，而无需修改Application类的代码。这就是抽象工厂模式的魅力。

4.区别总结

应用层次不同：简单工厂模式适合产品种类较少的情况；工厂方法模式适用于一个类别下有多个种类的情况；抽象工厂模式适用于有多个产品族，且产品族中有多个种类的情况。
复杂度增加：从简单工厂到工厂方法，再到抽象工厂，设计的复杂度和理解难度是逐步增加的。
抽象级别：简单工厂模式的抽象级别最低，抽象工厂模式的抽象级别最高，工厂方法模式居中。
灵活性和可扩展性：简单工厂模式的灵活性和可扩展性最差，抽象工厂模式最好，工厂方法模式居中。