Java 工厂模式：概念、使用与最佳实践

简介

在 Java 编程中，工厂模式（Factory Pattern）是一种创建对象的设计模式，它提供了一种创建对象的方式，将对象的创建和使用分离，使得代码更具灵活性、可维护性和可扩展性。本文将详细介绍 Java 工厂模式的基础概念、使用方法、常见实践以及最佳实践，帮助读者深入理解并高效使用该模式。

目录

1. 基础概念
2. 使用方法
3. 常见实践
4. 最佳实践
5. 小结
6. 参考资料

基础概念

工厂模式属于创建型设计模式，其核心思想是定义一个创建对象的接口，让子类决定实例化哪个类。工厂模式主要分为三种类型： - 简单工厂模式（Simple Factory Pattern）：它是工厂模式的基础版本，通过一个工厂类来创建对象，根据传入的参数决定创建哪种类型的对象。 - 工厂方法模式（Factory Method Pattern）：定义一个创建对象的抽象方法，由具体的子类来实现该方法，从而决定创建哪种类型的对象。 - 抽象工厂模式（Abstract Factory Pattern）：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

使用方法

简单工厂模式

// 定义产品接口
interface Shape {
    void draw();
}

// 具体产品类：圆形
class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a circle");
    }
}

// 具体产品类：矩形
class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a rectangle");
    }
}

// 简单工厂类
class ShapeFactory {
    public static Shape getShape(String shapeType) {
        if (shapeType == null) {
            return null;
        }
        if (shapeType.equalsIgnoreCase("CIRCLE")) {
            return new Circle();
        } else if (shapeType.equalsIgnoreCase("RECTANGLE")) {
            return new Rectangle();
        }
        return null;
    }
}

// 测试代码
public class SimpleFactoryExample {
    public static void main(String[] args) {
        Shape circle = ShapeFactory.getShape("CIRCLE");
        circle.draw();

        Shape rectangle = ShapeFactory.getShape("RECTANGLE");
        rectangle.draw();
    }
}

工厂方法模式

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

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

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

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

// 具体工厂类：创建产品 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 FactoryMethodExample {
    public static void main(String[] args) {
        Factory factoryA = new ConcreteFactoryA();
        Product productA = factoryA.createProduct();
        productA.operation();

        Factory factoryB = new ConcreteFactoryB();
        Product productB = factoryB.createProduct();
        productB.operation();
    }
}

抽象工厂模式

// 定义产品 A 接口
interface ProductA {
    void use();
}

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

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

// 定义产品 B 接口
interface ProductB {
    void operate();
}

// 具体产品 B1
class ConcreteProductB1 implements ProductB {
    @Override
    public void operate() {
        System.out.println("Operating ConcreteProductB1");
    }
}

// 具体产品 B2
class ConcreteProductB2 implements ProductB {
    @Override
    public void operate() {
        System.out.println("Operating ConcreteProductB2");
    }
}

// 抽象工厂接口
interface AbstractFactory {
    ProductA createProductA();
    ProductB createProductB();
}

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

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

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

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

// 测试代码
public class AbstractFactoryExample {
    public static void main(String[] args) {
        AbstractFactory factory1 = new ConcreteFactory1();
        ProductA productA1 = factory1.createProductA();
        ProductB productB1 = factory1.createProductB();
        productA1.use();
        productB1.operate();

        AbstractFactory factory2 = new ConcreteFactory2();
        ProductA productA2 = factory2.createProductA();
        ProductB productB2 = factory2.createProductB();
        productA2.use();
        productB2.operate();
    }
}

常见实践

• 对象创建逻辑复杂：当对象的创建过程涉及到复杂的逻辑，如数据库连接、配置文件读取等，可以使用工厂模式将这些逻辑封装在工厂类中，提高代码的可读性和可维护性。
• 根据不同条件创建对象：根据不同的条件创建不同类型的对象，如根据用户输入、系统配置等。
• 创建对象的代码分散：当创建对象的代码分散在多个地方时，使用工厂模式可以将这些代码集中管理，便于统一维护。

最佳实践

• 遵循开闭原则：在设计工厂模式时，应尽量遵循开闭原则，即对扩展开放，对修改关闭。当需要添加新的产品类型时，只需添加新的具体产品类和具体工厂类，而不需要修改现有的代码。
• 使用枚举类型：在简单工厂模式中，可以使用枚举类型来代替字符串参数，提高代码的安全性和可读性。
• 结合依赖注入：将工厂类作为依赖注入到需要创建对象的类中，提高代码的可测试性和可维护性。

小结

工厂模式是 Java 中一种非常实用的设计模式，它将对象的创建和使用分离，提高了代码的灵活性、可维护性和可扩展性。本文介绍了工厂模式的三种类型：简单工厂模式、工厂方法模式和抽象工厂模式，并给出了相应的代码示例。同时，还介绍了工厂模式的常见实践和最佳实践，希望读者能够通过本文深入理解并高效使用工厂模式。

参考资料

• 《Effective Java》
• 《设计模式：可复用面向对象软件的基础》
• Java 官方文档