请编写一个工厂方法模式的实际应用案例代码。

八股文_设计模式面试题 0 9

参考回答

问题：编写一个工厂方法模式的实际应用案例代码。

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

// 具体产品A
class ProductA implements Product {
    @Override
    public void use() {
        System.out.println("使用产品A");
    }
}

// 具体产品B
class ProductB implements Product {
    @Override
    public void use() {
        System.out.println("使用产品B");
    }
}

// 抽象工厂
abstract class ProductFactory {
    public abstract Product createProduct();
}

// 具体工厂A
class ProductAFactory extends ProductFactory {
    @Override
    public Product createProduct() {
        return new ProductA();
    }
}

// 具体工厂B
class ProductBFactory extends ProductFactory {
    @Override
    public Product createProduct() {
        return new ProductB();
    }
}

// 客户端
public class FactoryMethodExample {
    public static void main(String[] args) {
        ProductFactory factoryA = new ProductAFactory();
        Product productA = factoryA.createProduct();
        productA.use();

        ProductFactory factoryB = new ProductBFactory();
        Product productB = factoryB.createProduct();
        productB.use();
    }
}

详细讲解与拓展

1. 工厂方法模式的结构

产品接口（Product）：定义了所有具体产品的公共接口，客户端通过该接口与具体产品进行交互。
具体产品（ProductA 和 ProductB）：实现了产品接口，提供具体的实现。
抽象工厂（ProductFactory）：定义了一个抽象方法 createProduct()，该方法用于创建产品。
具体工厂（ProductAFactory 和 ProductBFactory）：每个具体工厂负责创建一种具体产品，并实现 createProduct() 方法。
客户端（FactoryMethodExample）：客户端通过具体工厂获取产品实例，调用产品的方法。

2. 核心思想

工厂方法模式将产品的创建推迟到子类中进行处理，客户端不再关心具体的产品类型，而是通过调用工厂方法来获取产品实例。每个具体工厂类负责创建一种特定的产品，子类化工厂类便于扩展更多类型的产品。

3. 优点
– 符合开放封闭原则：新增产品只需要扩展新的工厂，而不需要修改现有的代码。
– 避免了在客户端中直接创建产品：客户端只需要依赖抽象工厂，而不需要知道具体产品类的名称。
– 提高了灵活性和可维护性：当产品类变动时，客户端无需调整，只需在工厂类中做修改。

4. 缺点
– 类的数量增加：为了每种产品都创建一个工厂类，会使得系统中的类的数量增加，增加了代码的复杂性。
– 适用于产品变化较少的场景：如果产品种类变化频繁，工厂类也需要不断扩展，这在某些场景下可能会带来额外的工作量。

5. 扩展
– 抽象工厂模式：如果系统需要创建一系列相关的产品，而不仅仅是单个产品时，可以扩展为抽象工厂模式。抽象工厂会提供多个工厂方法，每个工厂方法负责创建一个系列的产品。
– 工厂方法与简单工厂的对比：简单工厂模式是通过一个工厂类来创建所有产品，而工厂方法模式则通过多个具体工厂类来处理不同产品的创建，灵活性更高。

举个例子：

假设我们开发一个日志系统，支持多种日志记录方式（文件日志、控制台日志）。我们可以使用工厂方法模式来管理不同类型的日志对象：

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

// 具体日志：文件日志
class FileLogger implements Logger {
    @Override
    public void log(String message) {
        System.out.println("写入文件日志: " + message);
    }
}

// 具体日志：控制台日志
class ConsoleLogger implements Logger {
    @Override
    public void log(String message) {
        System.out.println("输出控制台日志: " + message);
    }
}

// 抽象日志工厂
abstract class LoggerFactory {
    public abstract Logger createLogger();
}

// 具体工厂：文件日志工厂
class FileLoggerFactory extends LoggerFactory {
    @Override
    public Logger createLogger() {
        return new FileLogger();
    }
}

// 具体工厂：控制台日志工厂
class ConsoleLoggerFactory extends LoggerFactory {
    @Override
    public Logger createLogger() {
        return new ConsoleLogger();
    }
}

// 客户端
public class LoggerFactoryExample {
    public static void main(String[] args) {
        LoggerFactory fileLoggerFactory = new FileLoggerFactory();
        Logger fileLogger = fileLoggerFactory.createLogger();
        fileLogger.log("文件日志测试");

        LoggerFactory consoleLoggerFactory = new ConsoleLoggerFactory();
        Logger consoleLogger = consoleLoggerFactory.createLogger();
        consoleLogger.log("控制台日志测试");
    }
}

在这个例子中，LoggerFactory 是抽象工厂类，而 FileLoggerFactory 和 ConsoleLoggerFactory 是具体工厂类。每个具体工厂负责创建不同类型的日志记录器。客户端通过具体工厂获取相应的日志对象并调用其方法。

总结

工厂方法模式是创建型模式的一种，通过将产品的创建过程延迟到子类中来实现产品的多样化，避免了客户端直接依赖具体的产品类。它符合开放封闭原则，适用于产品种类不频繁变化的场景。然而，它会增加系统中的类数量，在产品种类增加时可能会导致工厂类的数量过多。

参考回答

详细讲解与拓展

举个例子：

总结

发表评论 取消回复

发表评论取消回复