Java 工厂模式示例详解

简介

在 Java 编程中，设计模式是解决常见问题的通用解决方案。工厂模式作为一种创建型设计模式，提供了一种创建对象的方式，将对象的创建和使用分离。这使得代码的可维护性和可扩展性得到极大提升。本文将详细介绍 Java 工厂模式示例，包括基础概念、使用方法、常见实践以及最佳实践。

基础概念

工厂模式的核心思想是将对象的创建逻辑封装在一个工厂类中，而不是在客户端代码中直接实例化对象。这样做的好处是，当对象的创建逻辑发生变化时，只需要修改工厂类，而不需要修改所有使用该对象的客户端代码。

工厂模式主要有三种类型： - 简单工厂模式：简单工厂模式不属于 GOF 23 种设计模式之一，但它是工厂模式的基础。它定义了一个工厂类，用于创建产品对象。 - 工厂方法模式：工厂方法模式是在简单工厂模式的基础上，将创建方法抽象成抽象方法，由具体的工厂子类实现。 - 抽象工厂模式：抽象工厂模式提供了一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

使用方法

简单工厂模式

简单工厂模式包含三个角色： - 工厂类（Creator）：负责创建产品对象。 - 产品类（Product）：定义产品的接口或抽象类。 - 具体产品类（ConcreteProduct）：实现产品接口或继承产品抽象类。

示例代码：

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

// 具体产品类
class ConcreteProduct implements Product {
    @Override
    public void operation() {
        System.out.println("执行具体产品的操作");
    }
}

// 工厂类
class SimpleFactory {
    public Product createProduct() {
        return new ConcreteProduct();
    }
}

// 客户端代码
public class SimpleFactoryExample {
    public static void main(String[] args) {
        SimpleFactory factory = new SimpleFactory();
        Product product = factory.createProduct();
        product.operation();
    }
}

工厂方法模式

工厂方法模式在简单工厂模式的基础上，将创建方法抽象成抽象方法，由具体的工厂子类实现。它包含四个角色： - 抽象工厂类（Creator）：定义创建产品的抽象方法。 - 具体工厂类（ConcreteCreator）：实现抽象工厂类的创建方法。 - 产品类（Product）：定义产品的接口或抽象类。 - 具体产品类（ConcreteProduct）：实现产品接口或继承产品抽象类。

示例代码：

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

// 具体产品类
class ConcreteProduct implements Product {
    @Override
    public void operation() {
        System.out.println("执行具体产品的操作");
    }
}

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

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

// 客户端代码
public class FactoryMethodExample {
    public static void main(String[] args) {
        Factory factory = new ConcreteFactory();
        Product product = factory.createProduct();
        product.operation();
    }
}

抽象工厂模式

抽象工厂模式提供了一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。它包含五个角色： - 抽象工厂类（AbstractFactory）：定义创建一系列产品的抽象方法。 - 具体工厂类（ConcreteFactory）：实现抽象工厂类的创建方法。 - 抽象产品类（AbstractProduct）：定义产品的接口或抽象类。 - 具体产品类（ConcreteProduct）：实现抽象产品类的接口或继承抽象产品类。 - 客户端（Client）：使用抽象工厂类创建产品对象。

示例代码：

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

// 具体产品 A1
class ConcreteProductA1 implements AbstractProductA {
    @Override
    public void operationA() {
        System.out.println("执行具体产品 A1 的操作");
    }
}

// 具体产品 A2
class ConcreteProductA2 implements AbstractProductA {
    @Override
    public void operationA() {
        System.out.println("执行具体产品 A2 的操作");
    }
}

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

// 具体产品 B1
class ConcreteProductB1 implements AbstractProductB {
    @Override
    public void operationB() {
        System.out.println("执行具体产品 B1 的操作");
    }
}

// 具体产品 B2
class ConcreteProductB2 implements AbstractProductB {
    @Override
    public void operationB() {
        System.out.println("执行具体产品 B2 的操作");
    }
}

// 抽象工厂类
abstract class AbstractFactory {
    public abstract AbstractProductA createProductA();
    public abstract AbstractProductB createProductB();
}

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

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

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

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

// 客户端代码
public class AbstractFactoryExample {
    public static void main(String[] args) {
        AbstractFactory factory1 = new ConcreteFactory1();
        AbstractProductA productA1 = factory1.createProductA();
        AbstractProductB productB1 = factory1.createProductB();
        productA1.operationA();
        productB1.operationB();

        AbstractFactory factory2 = new ConcreteFactory2();
        AbstractProductA productA2 = factory2.createProductA();
        AbstractProductB productB2 = factory2.createProductB();
        productA2.operationA();
        productB2.operationB();
    }
}

常见实践

对象创建逻辑复杂时：当对象的创建过程涉及到多个步骤、复杂的初始化逻辑或依赖其他对象时，使用工厂模式将创建逻辑封装在工厂类中，可以使客户端代码更加简洁。
根据不同条件创建对象时：例如根据配置文件、用户选择或运行时环境等条件创建不同类型的对象，工厂模式可以通过在工厂类中添加逻辑来实现。
代码维护和扩展：当需要添加新的产品类型或修改产品的创建逻辑时，只需要在工厂类中进行修改，而不会影响到其他大量的客户端代码。

最佳实践

单一职责原则：工厂类应该只负责对象的创建，避免承担过多的职责。如果工厂类的创建逻辑过于复杂，可以进一步拆分工厂类。
依赖注入：在工厂类中，可以使用依赖注入的方式来获取创建对象所需的依赖，这样可以提高代码的可测试性和可维护性。
缓存机制：对于一些创建成本较高的对象，可以在工厂类中添加缓存机制，避免重复创建相同的对象。

小结

工厂模式是 Java 编程中一种非常实用的设计模式，它将对象的创建和使用分离，提高了代码的可维护性和可扩展性。通过简单工厂模式、工厂方法模式和抽象工厂模式的不同应用场景，我们可以根据实际需求选择合适的工厂模式来优化代码结构。在实际开发中，遵循最佳实践可以使代码更加健壮和高效。

参考资料

《Effective Java》
《设计模式 - 可复用的面向对象软件元素》
Oracle Java 官方文档

Java 工厂模式示例详解

简介

目录

基础概念

使用方法

简单工厂模式

工厂方法模式

抽象工厂模式

常见实践

最佳实践

小结

参考资料