一. 前言

1. 定义

SimpleFactoryPattern：简单工厂模式又叫做静态工厂方法模式（因为工厂类定义了一个静态方法），定义一个用于创建对象的接口，让子类决定实例化哪个类。

Factory Method：工厂方法模式，又称工厂模式、多态工厂模式和虚拟构造器模式，通过定义工厂父类负责定义创建对象的公共接口，而子类则负责生成具体的对象。将类的实例化（具体产品的创建）延迟到工厂类的子类（具体工厂）中完成，即由子类来决定应该实例化（创建）哪一个类。

Abstract Factory：抽象工厂模式，即Abstract Factory Pattern，提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类；具体的工厂负责实现具体的产品实例。抽象工厂模式与工厂方法模式最大的区别：抽象工厂中每个工厂可以创建多种类的产品；而工厂方法每个工厂只能创建一类。允许使用抽象的接口来创建一组相关产品，而不需要知道或关心实际生产出的具体产品是什么，这样就可以从具体产品中被解耦。

二. 简单工厂模式

1. 概况

背景：一个工厂生产多种产品。

2. 代码

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
57
58
59
60
61
62
63
64
65
66
67
public class SimpleFactoryPattern {
    /**
     * 抽象产品类
     */
    public interface Product {
        void show();
    }

    /**
     * 具体的产品类-A
     */
    public static class ProductA implements Product {

        @Override
        public void show() {
            System.out.println("Product A");
        }
    }

    /**
     * 具体的产品类-B
     */
    public static class ProductB implements Product {

        @Override
        public void show() {
            System.out.println("Product B");
        }
    }

    /**
     * 工厂类
     */
    public static class ProductFactory {
        public static Product createProduct(String type){
            Product product = null;

            switch (type){
                case "A":
                    product = new ProductA();
                    break;
                case "B":
                    product = new ProductB();
                    break;
            }

            return product;
        }
    }

    /**
     * 测试
     */
    public static void main(String[] args) {
        //生产ProductA
        ProductFactory.createProduct("A").show();
        //生产ProductB
        ProductFactory.createProduct("B").show();

        try {
            //生产ProductC
            ProductFactory.createProduct("C").show();
        }catch (NullPointerException e) {
            System.out.println("没有 Product C");
        }
    }
}
1
2
3
4
//运行结果
Product A
Product B
没有 Product C

3. 优点

代码解耦，创建实例的工作与使用实例的工作分开，使用者不必关心类对象如何创建。

4. 缺点

  • 违背开放封闭原则，若需添加新产品则必须修改工厂类逻辑，会造成工厂逻辑过于复杂。

  • 简单工厂模式使用了静态工厂方法，因此静态方法不能被继承和重写。

  • 工厂类包含了所有实例（产品）的创建逻辑，若工厂类出错，则会造成整个系统都会会受到影响。

5. 应用场景

生成复杂对象时，确定只有一个工厂类，可以使用简单工厂模式。否则有多个工厂类的话，使用工厂方法模式。

三. 工厂方法模式

1. 概况

背景：有多个工厂，每个工厂只生产一种产品。

2. 代码

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
57
58
59
60
61
62
63
64
65
66
67
68
69
70
public class FactoryMethodPattern {
    /**
     * 抽象产品类
     */
    public interface Product {
        void show();
    }

    /**
     * 具体的产品类-A
     */
    public static class ProductA implements Product {

        @Override
        public void show() {
            System.out.println("Product A");
        }
    }

    /**
     * 具体的产品类-B
     */
    public static class ProductB implements Product {

        @Override
        public void show() {
            System.out.println("Product B");
        }
    }

    /**
     * 抽象的工厂类
     */
    public static abstract class ProductFactory {
        public abstract Product createProduct();
    }

    /**
     * 具体工厂类A
     */
    public static class ProductFactoryA extends ProductFactory {

        @Override
        public Product createProduct() {
            return new ProductA();
        }
    }

    /**
     * 具体工厂类B
     */
    public static class ProductFactoryB extends ProductFactory {

        @Override
        public Product createProduct() {
            return new ProductB();
        }
    }

    /**
     * 测试
     */
    public static void main(String[] args) {
        //创建 Product A
        new ProductFactoryA().createProduct().show();
        //创建 Product B
        new ProductFactoryB().createProduct().show();
    }

}
1
2
3
//运行结果
Product A
Product B

3. Android系统中的使用

Android中的ThreadFactory就是使用了工厂方法模式来生成线程的，线程就是ThreadFactory的产品。

4. 优点

  • 符合 开放封闭原则 。新增产品时，只需增加相应的具体产品类和相应的工厂子类即可。
  • 符合 单一职责原则 。每个具体工厂类只负责创建对应的产品。

5. 缺点

  • 一个具体工厂只能创建一种具体产品。
  • 增加新产品时，还需增加相应的工厂类，系统类的个数将成对增加，增加了系统的复杂度和性能开销。
  • 引入的抽象类也会导致类结构的复杂化。

6. 应用场景

生成复杂对象时，无需知道具体类名，只需知道相应的工厂方法即可。

四. 抽象工厂模式

1. 概况

背景：有多个工厂，每个工厂生产多种产品。

2. 代码

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
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
/**
 * 抽象工厂模式
 */
public class AbstractFactoryPattern {
    /**
     * 抽象的产品类
     */
    public interface CPU {
        void showCPU();
    }
    public interface Memory {
        void showMemory();
    }
    public interface HD {
        void showHD();
    }

    /**
     * 具体的产品类
     */
    public static class IntelCPU implements CPU {

        @Override
        public void showCPU() {
            System.out.println("Intel CPU");
        }
    }
    public static class AmdCPU implements CPU {

        @Override
        public void showCPU() {
            System.out.println("AMD CPU");
        }
    }
    public static class SanXinMemory implements Memory {

        @Override
        public void showMemory() {
            System.out.println("三星 Memory");

        }
    }
    public static class KingstonMemory implements Memory {

        @Override
        public void showMemory() {
            System.out.println("金士顿 Memory");
        }
    }
    public static class XiJieHD implements HD {

        @Override
        public void showHD() {
            System.out.println("希捷 硬盘");
        }
    }
    public static class XiBuHD implements HD {

        @Override
        public void showHD() {
            System.out.println("西部数据 硬盘");
        }
    }

    /**
     * 抽象的工厂类
     */
    public static abstract class ComputerFactory {
        public abstract CPU createCPU();
        public abstract Memory createMemory();
        public abstract HD createHD();
    }

    /**
     * 具体的工厂类
     */
    public static class AppleFactory extends ComputerFactory {

        @Override
        public CPU createCPU() {
            return new IntelCPU();
        }

        @Override
        public Memory createMemory() {
            return new SanXinMemory();
        }

        @Override
        public HD createHD() {
            return new XiBuHD();
        }
    }

    public static class LianXianFactory extends ComputerFactory {

        @Override
        public CPU createCPU() {
            return new AmdCPU();
        }

        @Override
        public Memory createMemory() {
            return new KingstonMemory();
        }

        @Override
        public HD createHD() {
            return new XiJieHD();
        }
    }

    /**
     * 测试
     */
    public static void main(String[] args) {
        System.out.println("--------------------生产苹果电脑-----------------------");
        AppleFactory appleFactory = new AppleFactory();
        appleFactory.createCPU().showCPU();
        appleFactory.createMemory().showMemory();
        appleFactory.createHD().showHD();

        System.out.println("--------------------生产联想电脑-----------------------");
        LianXianFactory lianXianFactory = new LianXianFactory();
        lianXianFactory.createCPU().showCPU();
        lianXianFactory.createMemory().showMemory();
        lianXianFactory.createHD().showHD();
    }
}
1
2
3
4
5
6
7
8
9
//运行结果
--------------------生产苹果电脑-----------------------
Intel CPU
三星 Memory
西部数据 硬盘
--------------------生产联想电脑-----------------------
AMD CPU
金士顿 Memory
希捷 硬盘

3. 优点

代码解耦，创建实例的工作与使用实例的工作分开，使用者不必关心类对象如何创建。

4. 缺点

如果增加新的产品,则修改抽象工厂和所有的具体工厂,违反了 开放封闭原则。

5. 应用场景

生产多个产品组合的对象时。

参考文章

Android的设计模式-简单工厂模式

简单工厂模式（SimpleFactoryPattern）- 最易懂的设计模式解析

Android的设计模式-工厂方法模式

工厂方法模式（Factory Method）- 最易懂的设计模式解析

Android的设计模式-抽象工厂模式

抽象工厂模式（Abstract Factory）- 最易懂的设计模式解析