【24种设计模式】工厂模式（Factory Pattern）

工厂模式是一种创建型设计模式，它提供了一种创建对象的方式，而无需暴露对象创建的逻辑。在这篇博客中，我们将介绍工厂模式的概念、使用场景以及示例代码。

概念

工厂模式是一种创建型设计模式，它提供了一种创建对象的方式，而无需暴露对象创建的逻辑。在工厂模式中，我们定义一个工厂接口，该接口包含一个创建对象的方法。然后，我们实现该接口并提供自己的实现方式。客户端代码只需要调用工厂接口的方法来创建对象，而无需关心对象的具体创建方式。

使用场景

工厂模式通常在以下情况下使用：

• 当创建对象的过程比较复杂或需要进行大量计算时，可以使用工厂模式来隐藏对象创建的逻辑。
• 当我们需要根据不同的条件创建不同类型的对象时，可以使用工厂模式。例如，根据不同的操作系统创建不同的对话框。
• 当我们需要为应用程序提供可扩展性时，可以使用工厂模式。例如，我们可以通过添加新的工厂来创建新的对象类型，而无需修改现有的代码。

示例代码

下面是一个使用工厂模式创建不同类型的汽车的示例代码：

// 定义汽车接口
interface Car {
    void drive();
}

// 实现不同类型的汽车
class SedanCar implements Car {
    @Override
    public void drive() {
        System.out.println("Driving a sedan car");
    }
}

class SUVCar implements Car {
    @Override
    public void drive() {
        System.out.println("Driving an SUV car");
    }
}

// 定义工厂接口
interface CarFactory {
    Car createCar();
}

// 实现不同类型的工厂
class SedanCarFactory implements CarFactory {
    @Override
    public Car createCar() {
        return new SedanCar();
    }
}

class SUVCarFactory implements CarFactory {
    @Override
    public Car createCar() {
        return new SUVCar();
    }
}

// 客户端代码
public class Main {
    public static void main(String[] args) {
        // 创建不同类型的工厂
        CarFactory sedanCarFactory = new SedanCarFactory();
        CarFactory suvCarFactory = new SUVCarFactory();

        // 使用工厂创建不同类型的汽车
        Car sedanCar = sedanCarFactory.createCar();
        Car suvCar = suvCarFactory.createCar();

        // 驾驶汽车
        sedanCar.drive();
        suvCar.drive();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

在这个示例中，我们定义了一个汽车接口，并实现了两种不同类型的汽车。然后，我们定义了一个工厂接口，并实现了两种不同类型的工厂。最后，我们使用这些工厂来创建不同类型的汽车，并调用汽车的drive方法。

需要注意的是，客户端代码只需要使用工厂接口来创建汽车，而无需关心汽车的具体实现方式。这种方式使得代码更加灵活和可扩展。

当我们使用工厂模式时，可以将对象的创建逻辑封装在工厂类中。这样做的好处是，客户端代码与具体的对象创建逻辑解耦，使得代码更加可维护和可扩展。

工厂模式有多种变体，包括简单工厂模式、工厂方法模式和抽象工厂模式。在上面的示例中，我们使用的是简单工厂模式，其中一个工厂类负责创建不同类型的对象。下面我们来看看其他两种变体的示例。

工厂方法模式

工厂方法模式中，我们将对象的创建交给子类来处理。每个具体的产品都有一个对应的工厂类，该工厂类负责创建该产品的实例。

// 定义汽车接口
interface Car {
    void drive();
}

// 实现不同类型的汽车
class SedanCar implements Car {
    @Override
    public void drive() {
        System.out.println("Driving a sedan car");
    }
}

class SUVCar implements Car {
    @Override
    public void drive() {
        System.out.println("Driving an SUV car");
    }
}

// 定义工厂接口
interface CarFactory {
    Car createCar();
}

// 实现具体的工厂类
class SedanCarFactory implements CarFactory {
    @Override
    public Car createCar() {
        return new SedanCar();
    }
}

class SUVCarFactory implements CarFactory {
    @Override
    public Car createCar() {
        return new SUVCar();
    }
}

// 客户端代码
public class Main {
    public static void main(String[] args) {
        // 创建不同类型的工厂
        CarFactory sedanCarFactory = new SedanCarFactory();
        CarFactory suvCarFactory = new SUVCarFactory();

        // 使用工厂创建不同类型的汽车
        Car sedanCar = sedanCarFactory.createCar();
        Car suvCar = suvCarFactory.createCar();

        // 驾驶汽车
        sedanCar.drive();
        suvCar.drive();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

在这个示例中，我们定义了一个汽车接口，并实现了两种不同类型的汽车。然后，我们定义了一个工厂接口，每个具体的产品都有一个对应的工厂类，负责创建该产品的实例。最后，我们使用具体的工厂类来创建不同类型的汽车。

抽象工厂模式

抽象工厂模式是工厂方法模式的扩展，它提供了一种创建一系列相关或相互依赖对象的方式。在抽象工厂模式中，我们定义了一个抽象工厂接口，该接口包含多个创建对象的方法。然后，我们实现该接口并提供自己的实现方式。

// 定义汽车接口
interface Car {
    void drive();
}

// 实现不同类型的汽车
class SedanCar implements Car {
    @Override
    public void drive() {
        System.out.println("Driving a sedan car");
    }
}

class SUVCar implements Car {
    @Override
    public void drive() {
        System.out.println("Driving an SUV car");
    }
}

// 定义工厂接口
interface CarFactory {
    Car createSedanCar();
    Car createSUVCar();
}

// 实现具体的工厂类
class CarFactoryImpl implements CarFactory {
    @Override
    public Car createSedanCar() {
        return new SedanCar();
    }

    @Override
    public Car createSUVCar() {
        return new SUVCar();
    }
}

// 客户端代码
public class Main {
    public static void main(String[] args) {
        // 创建工厂
        CarFactory carFactory = new CarFactoryImpl();

        // 使用工厂创建不同类型的汽车
        Car sedanCar = carFactory.createSedanCar();
        Car suvCar = carFactory.createSUVCar();

        // 驾驶汽车
        sedanCar.drive();
        suvCar.drive();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

在这个示例中，我们定义了一个汽车接口，并实现了两种不同类型的汽车。然后，我们定义了一个抽象工厂接口，该接口包含多个创建对象的方法。最后，我们使用具体的工厂类来创建不同类型的汽车。

无论是简单工厂模式、工厂方法模式还是抽象工厂模式，它们都提供了一种灵活的方式来创建对象，使得代码更加可维护和可扩展。根据实际需求，选择适合的工厂模式来创建对象，可以提高代码的可读性和可复用性。