Java 中的工厂设计模式示例详解

简介

在软件开发中，设计模式是经过反复实践总结出来的通用解决方案，能够帮助开发者更高效地构建可维护、可扩展的软件系统。工厂设计模式是其中一种创建型设计模式，它提供了一种创建对象的方式，将对象的创建和使用分离。通过使用工厂模式，我们可以在不直接实例化对象的情况下获取所需的对象，从而提高代码的灵活性和可维护性。在本文中，我们将深入探讨 Java 中的工厂设计模式，通过实际的代码示例来展示其基础概念、使用方法、常见实践以及最佳实践。

目录

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

基础概念

工厂设计模式定义了一个创建对象的接口或抽象类（工厂类），让子类决定实例化哪个类。工厂类负责对象的创建逻辑，而调用者只需要关心如何从工厂获取对象，而不需要了解对象具体的创建过程。这种分离使得代码的依赖关系更加清晰，调用者与具体的对象实现解耦。

工厂设计模式的组成部分

• 产品（Product）：这是工厂创建的对象类型，通常是一个接口或抽象类，具体的产品类实现这个接口或继承这个抽象类。
• 具体产品（Concrete Product）：实现产品接口或继承产品抽象类的具体类，代表实际要创建的对象。
• 工厂（Factory）：负责创建产品对象的类，它提供一个创建产品的方法，调用者通过这个方法获取产品对象。

使用方法

简单工厂模式（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 Shape createShape(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 SimpleFactoryPatternExample {
    public static void main(String[] args) {
        ShapeFactory factory = new ShapeFactory();
        Shape circle = factory.createShape("CIRCLE");
        if (circle != null) {
            circle.draw();
        }
        Shape rectangle = factory.createShape("RECTANGLE");
        if (rectangle != null) {
            rectangle.draw();
        }
    }
}

工厂方法模式示例

// 产品接口
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.");
    }
}

// 抽象工厂类
abstract class ShapeFactory {
    public abstract Shape createShape();
}

// 具体工厂类：圆形工厂
class CircleFactory extends ShapeFactory {
    @Override
    public Shape createShape() {
        return new Circle();
    }
}

// 具体工厂类：矩形工厂
class RectangleFactory extends ShapeFactory {
    @Override
    public Shape createShape() {
        return new Rectangle();
    }
}

// 测试代码
public class FactoryMethodPatternExample {
    public static void main(String[] args) {
        ShapeFactory circleFactory = new CircleFactory();
        Shape circle = circleFactory.createShape();
        if (circle != null) {
            circle.draw();
        }
        ShapeFactory rectangleFactory = new RectangleFactory();
        Shape rectangle = rectangleFactory.createShape();
        if (rectangle != null) {
            rectangle.draw();
        }
    }
}

抽象工厂模式示例

// 产品接口 1：形状
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.");
    }
}

// 产品接口 2：颜色
interface Color {
    void fill();
}

// 具体产品类：红色
class Red implements Color {
    @Override
    public void fill() {
        System.out.println("Filling with red.");
    }
}

// 具体产品类：蓝色
class Blue implements Color {
    @Override
    public void fill() {
        System.out.println("Filling with blue.");
    }
}

// 抽象工厂接口
interface AbstractFactory {
    Shape createShape();
    Color createColor();
}

// 具体工厂类：形状和颜色工厂
class ShapeColorFactory implements AbstractFactory {
    @Override
    public Shape createShape() {
        return new Circle();
    }

    @Override
    public Color createColor() {
        return new Red();
    }
}

// 测试代码
public class AbstractFactoryPatternExample {
    public static void main(String[] args) {
        AbstractFactory factory = new ShapeColorFactory();
        Shape shape = factory.createShape();
        if (shape != null) {
            shape.draw();
        }
        Color color = factory.createColor();
        if (color != null) {
            color.fill();
        }
    }
}

最佳实践

保持工厂类的单一职责

工厂类应该只负责对象的创建，避免在工厂类中添加过多与对象创建无关的业务逻辑，以保证代码的清晰和可维护性。

使用依赖注入

在工厂类中，可以通过依赖注入的方式获取创建对象所需的外部资源或配置信息，提高代码的灵活性和可测试性。

考虑使用枚举类型

如果产品类型有限且固定，可以使用枚举类型来表示产品类型，这样可以提高代码的可读性和安全性。

文档化工厂类的使用方法

为工厂类添加清晰的文档注释，说明其功能、输入参数和返回值，以便其他开发者能够正确使用。

小结

工厂设计模式是一种强大的创建型设计模式，它通过将对象的创建和使用分离，提高了代码的灵活性、可维护性和可扩展性。在本文中，我们介绍了简单工厂模式、工厂方法模式和抽象工厂模式的概念、使用方法，并通过实际的代码示例展示了它们的实现。同时，我们还讨论了工厂模式的常见实践和最佳实践，希望这些内容能够帮助读者更好地理解和应用工厂设计模式。

参考资料

• 《设计模式 - 可复用的面向对象软件元素》（Design Patterns - Elements of Reusable Object-Oriented Software）
• 《Effective Java》
• Oracle Java Documentation