设计模式教程：工厂方法模式

伯灵

发布于 2026-01-21 09:03:45

1200

工厂方法模式（Factory Method Pattern） 是一种创建型设计模式，它定义了一个创建对象的接口，但由子类决定实例化哪个类。工厂方法模式使得类的实例化推迟到子类中进行，从而达到解耦的目的。工厂方法模式的核心思想是把实例化对象的工作交给子类，而不是由客户端代码直接控制，这样可以使得代码更加灵活和可扩展。

1. 适用场景

工厂方法模式适用于以下情况：

当一个类无法预见它所需要创建的对象类型时，或是希望在类内创建多个类型的对象时。
当一个类希望通过其子类来指定创建对象的类型时。
当你想要避免在代码中直接使用new关键字来实例化对象，以便将实例化的责任推迟到子类中时。

2. 组成部分

工厂方法模式包含以下几个角色：

产品（Product）：定义了工厂方法所创建的对象的接口。
具体产品（ConcreteProduct）：实现了Product接口的具体类，代表具体的产品。
工厂（Creator）：定义了一个工厂方法，声明返回Product对象的接口。
具体工厂（ConcreteCreator）：实现了Creator中的工厂方法，负责实例化具体的产品对象。

3. 结构图

             +----------------+
             |    Creator     | <-- Abstract Factory (工厂)
             +----------------+
             | + factoryMethod()|  --> 工厂方法接口
             +----------------+
                     ^
                     |
             +------------------+
             | ConcreteCreator  | <-- 具体工厂
             +------------------+
             | + factoryMethod() |
             +------------------+
                     ^
                     |
              +-------------+
              |   Product   | <-- 产品接口
              +-------------+
              | + doSomething() |
              +-------------+
                     ^
                     |
             +-------------------+
             | ConcreteProduct   | <-- 具体产品
             +-------------------+
             | + doSomething()   |
             +-------------------+

4. 代码示例

假设我们有一个图形（Shape）接口，具体的图形类有圆形（Circle）和矩形（Rectangle）。我们希望通过工厂方法来创建这些图形对象，而不是直接在代码中用new来实例化它们。

1. 定义产品接口（Product）

// 产品接口：Shape
public interface Shape {
    void draw(); // 产品的具体方法
}

2. 具体产品类（ConcreteProduct）

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

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

3. 工厂接口（Creator）

// 工厂接口：Creator
public abstract class ShapeFactory {
    // 工厂方法：返回一个Shape类型的对象
    public abstract Shape createShape();
}

4. 具体工厂类（ConcreteCreator）

// 具体工厂1：CircleFactory
public class CircleFactory extends ShapeFactory {
    @Override
    public Shape createShape() {
        return new Circle(); // 返回一个Circle对象
    }
}

// 具体工厂2：RectangleFactory
public class RectangleFactory extends ShapeFactory {
    @Override
    public Shape createShape() {
        return new Rectangle(); // 返回一个Rectangle对象
    }
}

5. 客户端代码（Client）

public class Client {
    public static void main(String[] args) {
        // 使用工厂来创建对象，而不是直接new
        ShapeFactory circleFactory = new CircleFactory();
        Shape circle = circleFactory.createShape();
        circle.draw(); // 输出：Drawing Circle

        ShapeFactory rectangleFactory = new RectangleFactory();
        Shape rectangle = rectangleFactory.createShape();
        rectangle.draw(); // 输出：Drawing Rectangle
    }
}

5. 运行结果

Drawing Circle
Drawing Rectangle

6. 总结

工厂方法模式定义了一个创建对象的接口，但由子类决定实例化哪一个类。这样可以将对象的创建和具体类的使用解耦，提高代码的灵活性。
适用场景：
- 当类不知道它需要创建的对象的具体类型时。
- 当类希望由其子类来指定所创建的对象类型时。
- 当类希望将对象的创建推迟到子类中时。
优点：
- 可以扩展新的具体产品，只需要增加新的具体工厂类。
- 客户端代码不依赖于具体的类，增加了代码的可维护性和可扩展性。
- 可以将对象的创建和使用分离，提高了代码的灵活性。
缺点：
- 每增加一种产品，就需要增加一个具体工厂类，可能导致类的数量增加。
- 客户端需要了解具体的工厂类，从而导致一定程度的耦合。