设计模式使用场景实现示例及优缺点（创建型模式——工厂方法模式、抽象工厂模式）

创建型模式

工厂方法模式 (Factory Method Pattern)

工厂方法模式（Factory Method Pattern）是一种创建型设计模式，提供了一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法模式让类的实例化推迟到子类。这样，客户端代码将依赖于具体子类的实现，而不是直接依赖于具体的对象。

适用场景

1. 代码需要处理不同类型的对象，但不希望将对象的创建逻辑耦合到代码中：

   • 比如，在处理不同数据库类型（如 MySQL、PostgreSQL）时，可以使用工厂方法模式来创建数据库连接对象，而不需要在客户端代码中直接引用具体的数据库类。

2. 代码中涉及复杂的对象创建过程：

   • 如果对象的创建过程很复杂，包括许多步骤和配置，工厂方法模式可以将创建逻辑集中在一个地方，简化客户端代码。

3. 客户端代码不应依赖于具体类来创建对象：

   • 工厂方法模式使客户端代码依赖于抽象类或接口，从而提高代码的灵活性和可扩展性。

实现示例（Java）

下面是一个使用工厂方法模式的示例，展示如何创建不同类型的日志记录器（如文件日志记录器和数据库日志记录器）：

1. 定义产品接口或抽象类

public interface Logger {
    void log(String message);
}

2. 具体产品类实现接口或继承抽象类

public class FileLogger implements Logger {
    @Override
    public void log(String message) {
        System.out.println("File logger: " + message);
    }
}

public class DatabaseLogger implements Logger {
    @Override
    public void log(String message) {
        System.out.println("Database logger: " + message);
    }
}

3. 定义工厂方法的抽象类

public abstract class LoggerFactory {
    public abstract Logger createLogger();

    public void log(String message) {
        Logger logger = createLogger();
        logger.log(message);
    }
}

4. 具体工厂类实现工厂方法

public class FileLoggerFactory extends LoggerFactory {
    @Override
    public Logger createLogger() {
        return new FileLogger();
    }
}

public class DatabaseLoggerFactory extends LoggerFactory {
    @Override
    public Logger createLogger() {
        return new DatabaseLogger();
    }
}

5. 客户端代码

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

        // 使用文件日志记录器
        factory = new FileLoggerFactory();
        factory.log("This is a file log message.");

        // 使用数据库日志记录器
        factory = new DatabaseLoggerFactory();
        factory.log("This is a database log message.");
    }
}

工厂方法模式的优点

1. 代码解耦：

   • 客户端代码依赖于抽象产品接口或抽象工厂，而不是具体的产品类，从而实现了代码的解耦。

2. 提高灵活性：

   • 新的具体产品可以通过实现产品接口并创建相应的具体工厂类来添加，而无需修改现有代码。

3. 单一职责原则：

   • 将对象创建的责任委派给具体工厂类，符合单一职责原则。

工厂方法模式的缺点

1. 类的数量增加：

   • 每添加一种新的产品类型，都需要创建一个具体产品类和相应的具体工厂类，可能会导致类的数量增加。

2. 实现复杂：

   • 工厂方法模式可能会使代码结构变得复杂，特别是在存在多个产品层次结构时。

总结

工厂方法模式通过将对象的创建过程封装在工厂方法中，实现了客户端代码与具体产品类的解耦。它适用于对象创建过程复杂、多种类型的对象创建等场景，有助于提高代码的灵活性和可维护性。

抽象工厂模式

抽象工厂模式（Abstract Factory Pattern）是一种创建型设计模式，它提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。抽象工厂模式通过对产品类的工厂进行抽象，使得一个工厂可以生产多种类型的产品。

适用场景

1. 系统需要独立于产品创建的方式时：

   • 客户端代码不需要知道具体产品的创建过程，只需要知道如何使用抽象接口。

2. 系统有多个产品系列，每个系列有多种类型的产品时：

   • 例如，GUI库可能提供不同风格的窗口和按钮（如Windows风格和Mac风格），抽象工厂可以提供一个接口来创建不同风格的组件。

3. 需要保证产品系列的一致性时：

   • 抽象工厂模式确保同一个工厂创建的产品系列是兼容的。

实现示例（Java）

以下是一个简单的抽象工厂模式的实现示例，展示如何创建不同风格的GUI组件（如按钮和复选框）。

1. 定义抽象产品接口

// 抽象产品A
public interface Button {
    void paint();
}

// 抽象产品B
public interface Checkbox {
    void paint();
}

2. 具体产品类实现抽象产品接口

// 具体产品A1
public class WindowsButton implements Button {
    @Override
    public void paint() {
        System.out.println("Windows Button");
    }
}

// 具体产品A2
public class MacButton implements Button {
    @Override
    public void paint() {
        System.out.println("Mac Button");
    }
}

// 具体产品B1
public class WindowsCheckbox implements Checkbox {
    @Override
    public void paint() {
        System.out.println("Windows Checkbox");
    }
}

// 具体产品B2
public class MacCheckbox implements Checkbox {
    @Override
    public void paint() {
        System.out.println("Mac Checkbox");
    }
}

3. 定义抽象工厂接口

public interface GUIFactory {
    Button createButton();
    Checkbox createCheckbox();
}

4. 具体工厂类实现抽象工厂接口

// 具体工厂1
public class WindowsFactory implements GUIFactory {
    @Override
    public Button createButton() {
        return new WindowsButton();
    }

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

// 具体工厂2
public class MacFactory implements GUIFactory {
    @Override
    public Button createButton() {
        return new MacButton();
    }

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

5. 客户端代码

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();

        factory = new MacFactory();
        app = new Application(factory);
        app.paint();
    }
}

注释说明

1. 抽象产品接口：

   • Button 和 Checkbox 是两个抽象产品接口，定义了产品的通用行为（如 paint 方法）。

2. 具体产品类：

   • WindowsButton、MacButton、WindowsCheckbox 和 MacCheckbox 是具体产品类，它们实现了抽象产品接口，提供具体的产品行为。

3. 抽象工厂接口：

   • GUIFactory 是抽象工厂接口，定义了创建一系列相关产品的方法（如 createButton 和 createCheckbox）。

4. 具体工厂类：

   • WindowsFactory 和 MacFactory 是具体工厂类，它们实现了抽象工厂接口，提供了具体的产品创建方法。

5. 客户端代码：

   • Application 类通过依赖抽象工厂接口来创建产品。这样，客户端代码与具体产品类解耦，便于扩展和维护。

总结

抽象工厂模式通过对产品类和工厂类的抽象，使得客户端代码可以独立于具体产品类和工厂类进行工作。它适用于需要创建一系列相关或相互依赖对象的系统，有助于提高代码的灵活性和一致性。