Java 工厂设计模式详解

简介

在软件开发中，设计模式是解决常见问题的通用方案。工厂设计模式（Factory Design Pattern）是 Java 中一种创建型设计模式，它提供了一种创建对象的方式，将对象的创建和使用分离，提高了代码的可维护性和可扩展性。本文将详细介绍 Java 工厂设计模式的基础概念、使用方法、常见实践以及最佳实践。

目录

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

基础概念

定义

工厂设计模式定义了一个创建对象的接口，让子类决定实例化哪个类。工厂方法使一个类的实例化延迟到其子类。

角色

• 抽象工厂（Abstract Factory）：定义了创建产品对象的抽象方法，是工厂方法模式的核心。
• 具体工厂（Concrete Factory）：实现了抽象工厂的方法，负责创建具体的产品对象。
• 抽象产品（Abstract Product）：定义了产品的接口，是具体产品的父类。
• 具体产品（Concrete Product）：实现了抽象产品的接口，是工厂方法创建的目标对象。

优点

• 解耦对象的创建和使用：将对象的创建逻辑封装在工厂类中，使得代码的使用者只需要关注对象的使用，而不需要关心对象的创建过程。
• 提高代码的可维护性和可扩展性：当需要创建新的产品对象时，只需要添加新的具体工厂和具体产品类，而不需要修改现有的代码。

缺点

• 增加了代码的复杂度：引入了抽象工厂和具体工厂类，增加了代码的数量和复杂度。
• 违背了开闭原则：当需要创建新的产品对象时，需要修改抽象工厂类和具体工厂类，违背了开闭原则。

使用方法

步骤

1. 定义抽象产品接口。
2. 实现具体产品类。
3. 定义抽象工厂接口。
4. 实现具体工厂类。
5. 使用具体工厂类创建具体产品对象。

代码示例

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

// 抽象工厂接口
interface ShapeFactory {
    Shape createShape();
}

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

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

// 使用示例
public class FactoryPatternDemo {
    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();
    }
}

常见实践

简单工厂模式

简单工厂模式是工厂方法模式的一种简化形式，它将创建对象的逻辑封装在一个工厂类中，通过一个静态方法来创建对象。

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

// 使用示例
public class SimpleFactoryPatternDemo {
    public static void main(String[] args) {
        // 使用简单工厂创建圆形对象
        Shape circle = SimpleShapeFactory.createShape("circle");
        circle.draw();

        // 使用简单工厂创建矩形对象
        Shape rectangle = SimpleShapeFactory.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.");
    }

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

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

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

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

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

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

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

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

// 使用示例
public class AbstractFactoryPatternDemo {
    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》
• 《Head First Design Patterns》
• Java Design Patterns