Java 工厂类示例解析

简介

在 Java 编程中，工厂类（Factory Class）是一种创建对象的设计模式。它提供了一种将对象创建和使用分离的方式，使得代码的依赖关系更加清晰，易于维护和扩展。通过工厂类，我们可以将对象创建的逻辑封装在一个单独的类中，而不是在多个地方重复编写创建对象的代码。这篇博客将深入探讨工厂类在 Java 中的基础概念、使用方法、常见实践以及最佳实践。

目录

1. 基础概念
2. 使用方法
   • 简单工厂模式
   • 工厂方法模式
   • 抽象工厂模式
3. 常见实践
   • 创建对象的复杂逻辑封装
   • 依赖注入
4. 最佳实践
   • 单一职责原则
   • 可维护性和扩展性
5. 代码示例
   • 简单工厂模式示例
   • 工厂方法模式示例
   • 抽象工厂模式示例
6. 小结
7. 参考资料

基础概念

工厂类是一个专门负责创建对象的类。它提供了一个或多个方法，这些方法根据不同的条件或参数来创建不同类型的对象。工厂类的核心思想是将对象的创建过程封装起来，使得调用者不需要了解对象创建的具体细节，只需要关心如何获取到所需的对象。

工厂类模式主要有三种类型： - 简单工厂模式（Simple Factory Pattern）：简单工厂模式是工厂模式的基础，它定义了一个工厂类，该类有一个创建产品对象的方法，根据传入的参数决定创建哪种具体产品对象。简单工厂模式不属于 GoF 设计模式，但它是工厂方法模式和抽象工厂模式的基础。 - 工厂方法模式（Factory Method Pattern）：在工厂方法模式中，工厂类不再负责创建所有产品对象，而是将创建对象的方法抽象成抽象方法，由具体的工厂子类来实现。这样，每个具体工厂子类负责创建一种特定类型的产品对象。 - 抽象工厂模式（Abstract Factory Pattern）：抽象工厂模式中，工厂类创建一系列相关的产品对象。工厂类是抽象的，具体的创建逻辑由具体的工厂子类实现。每个具体工厂子类负责创建一组相关的产品对象。

使用方法

简单工厂模式

简单工厂模式的结构通常包含以下几个部分： - 产品接口（Product Interface）：定义产品的通用方法。 - 具体产品类（Concrete Product Classes）：实现产品接口，提供具体的功能。 - 工厂类（Factory Class）：包含一个创建产品对象的静态方法，根据传入的参数决定创建哪种具体产品对象。

工厂方法模式

工厂方法模式在简单工厂模式的基础上进行了扩展，其结构包含： - 产品接口（Product Interface）：与简单工厂模式相同，定义产品的通用方法。 - 具体产品类（Concrete Product Classes）：实现产品接口。 - 抽象工厂类（Abstract Factory Class）：定义一个抽象的创建产品对象的方法。 - 具体工厂类（Concrete Factory Classes）：继承抽象工厂类，实现创建产品对象的方法。

抽象工厂模式

抽象工厂模式的结构更为复杂，包含以下部分： - 产品接口（Product Interfaces）：定义不同类型产品的通用方法。 - 具体产品类（Concrete Product Classes）：实现相应的产品接口。 - 抽象工厂类（Abstract Factory Class）：定义一组创建不同类型产品对象的抽象方法。 - 具体工厂类（Concrete Factory Classes）：继承抽象工厂类，实现创建不同类型产品对象的方法。

常见实践

创建对象的复杂逻辑封装

当创建对象的过程涉及到复杂的初始化逻辑、资源获取或配置时，可以将这些逻辑封装在工厂类中。这样，在其他地方使用对象时，只需要调用工厂类的方法，而不需要关心复杂的创建过程。

依赖注入

在依赖注入（Dependency Injection）中，工厂类可以用来创建需要注入的对象。通过工厂类，我们可以更灵活地控制对象的创建过程，并且可以在不同的环境中使用不同的对象创建逻辑。

最佳实践

单一职责原则

工厂类应该遵循单一职责原则，即一个工厂类只负责创建一种或一组相关的对象。这样可以使得工厂类的职责清晰，易于维护和扩展。

可维护性和扩展性

在设计工厂类时，要考虑到代码的可维护性和扩展性。尽量使用接口和抽象类来定义产品和工厂，以便在需要添加新的产品或工厂时，不需要对现有代码进行大量修改。

代码示例

简单工厂模式示例

// 产品接口
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 createShape(String shapeType) {
        if ("circle".equalsIgnoreCase(shapeType)) {
            return new Circle();
        } else if ("rectangle".equalsIgnoreCase(shapeType)) {
            return new Rectangle();
        }
        return null;
    }
}

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

        Shape rectangle = ShapeFactory.createShape("rectangle");
        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 FactoryMethodExample {
    public static void main(String[] args) {
        ShapeFactory circleFactory = new CircleFactory();
        Shape circle = circleFactory.createShape();
        circle.draw();

        ShapeFactory rectangleFactory = new RectangleFactory();
        Shape rectangle = rectangleFactory.createShape();
        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.");
    }
}

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

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

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

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

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

// 测试代码
public class AbstractFactoryExample {
    public static void main(String[] args) {
        AbstractFactory circleRedFactory = new CircleRedFactory();
        Shape circle = circleRedFactory.createShape();
        circle.draw();
        Color red = circleRedFactory.createColor();
        red.fill();

        AbstractFactory rectangleBlueFactory = new RectangleBlueFactory();
        Shape rectangle = rectangleBlueFactory.createShape();
        rectangle.draw();
        Color blue = rectangleBlueFactory.createColor();
        blue.fill();
    }
}

小结

工厂类在 Java 编程中是一种非常有用的设计模式，它通过将对象创建和使用分离，提高了代码的可维护性和可扩展性。不同类型的工厂模式（简单工厂模式、工厂方法模式和抽象工厂模式）适用于不同的场景，开发者可以根据具体需求选择合适的模式。遵循最佳实践，如单一职责原则，可以使工厂类的设计更加合理和高效。

参考资料

• 《Effective Java》 by Joshua Bloch
• 《Design Patterns - Elements of Reusable Object-Oriented Software》 by Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides
• Oracle Java Documentation