概述

创建型模式的核心就是通过将创建对象和使用对象分离开来，去关注于怎样去创建一个对象。

单列模式

思维导图

UML 图

懒汉式单列实现代码

1
2
3
4
5
6
7
8
9
10
11
12
13
class LazyXorex {
    private static volatile LazyXorex instance=null;
    // instance 一定要通过 volatile 即使写入内存中！
    private LazyXorex() {
    }
    // 方法也要被锁住，方式多创建了实例
    public static synchronized LazyXorex getInstance() {
        if(instance==null) {
            instance=new LazyXorex();
        }
        return instance;
    }
}

饿汉式单列实现代码

1
2
3
4
5
6
7
8
9
10
class HungryXorex {
    private static HungryXorex instance=new HungryXorex();
    // 在类被加载到内存的时候 instance 就拥有了实例。
    private HungryXorex() {
    }

    public static HungryXorex getInstance() {
        return instance;
    }
}

原型模式

思维导图

UML 图

实现可克隆类

1
2
3
4
5
6
7
8
class Tempest implements Cloneable {
    public String Xorex="Xorex";
    
    @Override 
    protected Tempest clone() throws CloneNotSupportedException {
        return (Tempest)super.clone(); // 调用父类 Object 的 clone() 方法。
    }
}

简单工厂

思维导图

UML 图

实现内部封装的简单工厂

下面代码例子是使用简单工厂的方式获取不同的 Waifu 产品。步骤是通过相同的工厂 Factory 的静态方法 makeWaifu 来获取产品，waifu 产品的具体创建交给工厂的 makeWaifu 来决定。至于返回的是哪一个具体的 Waifu，我们并不需要关心，只需要用统一接口 Waifu 来接收并操作即可。

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
public class Test {
    public static void main(String[] args) {
        SimpleWaifuFactory.Waifu Yukino=SimpleWaifuFactory.Factory.makeWaifu(SimpleWaifuFactory.Yukinoshita_Yukino);
        SimpleWaifuFactory.Waifu Asuna=SimpleWaifuFactory.Factory.makeWaifu(SimpleWaifuFactory.Yuuki_Asuna);
        Yukino.selfIntroduction();
        Asuna.selfIntroduction();
    } // 外部调用简单工厂来获取对应的实例，然后调用里面的方法。
}

// 一个单独的 public 工厂
public class SimpleWaifuFactory {

    public static final int Yukinoshita_Yukino = 0;
    public static final int Yuuki_Asuna = 1;
    // 定义工厂接收的参数标准

    public interface Waifu {
        void selfIntroduction();
    } // 定义本工厂生产的产品的统一模板，让外部持有接口使用实例。

    private static class Yukino implements Waifu {
        public void selfIntroduction() {
            System.out.println("Ya~hello,There is Yukinoshita Yukino!");
        }
    } // 产品 Yukino 实例定义类

    static class Asuna implements Waifu {
        public void selfIntroduction() {
            System.out.println("Hi,I am Yuuki Asnua!");
        }
    } // 产品 Asuna 实例定义类

    static class Factory {
        public static Waifu makeWaifu(int waifuID) {
            switch (waifuID) {
                case Yukinoshita_Yukino:
                    return new Yukino();
                case Yuuki_Asuna:
                    return new Asuna();
            }
            return null;
        }
    } // 生成实例的工厂
}

实现外部散开工厂

这里代码需要注意，所有的工厂相关类都需要写在一个包里面，保证非 public 类型（不对外开放的）产品类只能被包内的工厂访问。

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
public class SimpleFactory {
    public static void main(String[] args) {
        Waifu Yukino=SimpleWaifuFactory.makeWaifu(SimpleWaifuFactory.Yukinoshita_Yukino);
        Waifu Asuna=SimpleWaifuFactory.makeWaifu(SimpleWaifuFactory.Yuuki_Asuna);
        Yukino.selfIntroduction();
        Asuna.selfIntroduction();
    } // 外部调用简单工厂来获取对应的实例，然后调用里面的方法。
}

// 一个单独的 public 工厂
public class SimpleWaifuFactory {

    public static final int Yukinoshita_Yukino = 0;
    public static final int Yuuki_Asuna = 1;
    // 定义工厂接收的参数标

    public static Waifu makeWaifu(int waifuID) {
        switch (waifuID) {
            case Yukinoshita_Yukino:
                return new Yukino();
            case Yuuki_Asuna:
                return new Asuna();
        }
        return null;
    } // 生成实例的工厂
}

public interface Waifu {
    void selfIntroduction();
} // 定义本工厂生产的产品的统一模板，让外部持有接口使用实例。

class Yukino implements Waifu {
    public void selfIntroduction() {
        System.out.println("Ya~hello,There is Yukinoshita Yukino!");
    }
} // 产品 Yukino 实例定义类

class Asuna implements Waifu {
    public void selfIntroduction() {
        System.out.println("Hi,I am Yuuki Asnua!");
    }
} // 产品 Asuna 实例定义类

工厂方法模式

思维导图

UML 图

代码实现

主要是从简单工厂模式的一个工厂对应不同产品到工厂模式的不同工厂对应不同产品，来实现开闭原则。一旦有产品增加，可以通过增加工厂的方式来实现需求，不需要像简单工厂那样去修改原有的工厂代码。但简单工厂的代码修改可以限制在增加生产方法上面，其实也很好维护。

下面的代码通过不同的电视工厂来获取不同的电视产品，比如通过小米电视工厂获取小米电视，华为电视工厂获取华为电视，比简单工厂模式多了一个工厂接口，因此可以建立不同的工厂满足种类繁多的产品的创建，一类工厂满足一类产品。

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
public class Consumer {
    public static void main(String[] args) {
        TVFactroy MiF=new MiTVFactory();
        TV MiTv=MiF.getTV();
        MiTv.Show();

        TVFactroy HuaweiF=new HuaweiTVFactory();
        TV HuaweiTv=HuaweiF.getTV();
        HuaweiTv.Show();
    }
    
}

// 相较于简单工厂模式增加了一个工厂接口，通过扩展工厂类的方式代替修改工厂代码
interface TVFactroy {
    TV getTV();
}

// 不同的产品对应不同的工厂
class MiTVFactory implements TVFactroy {
    @Override
    public TV getTV() {
        return new MiTV4s70();
    }
    
}

class HuaweiTVFactory implements TVFactroy {
    @Override
    public TV getTV() {
        return new HuaweiTV65();
    }
    
}

interface TV {
    void Show();
}

class MiTV4s70 implements TV {
    @Override
    public void Show() {
        System.out.println("I am MiTV4s70");
    }
}

class HuaweiTV65 implements TV {
    @Override
    public void Show() {
        System.out.println("I am HuaweiTV65");
    }
}

抽象工厂模式

思维导图

UML 图

代码实现

下面的代码通过建立小米族产品超级工厂和华为族产品超级工厂实现超级抽象工厂接口，这些超级工厂生产不同级产品。如通过抽象工厂接口 SuperFactory 操作小米工厂 MiFactory 的不同生产方法，如 getTV() 获取实现了抽象产品 TV 的实际产品 MiTV，用 getPhone() 获取实现了抽象产品 Phone 的实际产品 Mi11。不同工厂的同级产品，实现的抽象产品接口都是一样的。比如小米工厂生产的 Mi11 产品和华为工厂生产的 HUAWEIMate40Pro 产品同级，都是实现了抽象产品接口 Phone。

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
public class Consumer {
    public static void main(String[] args) {

        //展示消费者通过超级工厂获取产品的实例
        System.out.println("I am a Mi-funs");
        SuperFactory Mi=new MiFactory();
        Phone MiPhone=Mi.getPhone();
        TV MiTV=Mi.getTV();
        MiPhone.call();
        MiTV.watchTV();
        System.out.println();

        System.out.println("I am a HUAWEI-funs");
        SuperFactory HUAWEI=new HUAWEIFactory();
        Phone HUAWEIPhone=HUAWEI.getPhone();
        TV HUAWEITV=HUAWEI.getTV();
        HUAWEIPhone.call();
        HUAWEITV.watchTV();

    }
}

// 定义超级工厂的同族不同级的产品生产
interface SuperFactory {
    Phone getPhone();
    TV getTV();
}

// 小米工厂
class MiFactory implements SuperFactory {

    @Override
    public Phone getPhone() {
        return new Mi11();
    }

    @Override
    public TV getTV() {
        return new MiTV4s65();
    }
}


// 华为工厂
class HUAWEIFactory implements SuperFactory{

    @Override
    public Phone getPhone() {
        return new HUAWEIMate40Pro();
    }

    @Override
    public TV getTV() {
        return new HAUWEIX70();
    }
}

// 定义手机产品统一功能
interface Phone {
    void call();
}

// 定义电视产品统一功能
interface TV {
    void watchTV();
}

// 具体产品
class Mi11 implements Phone {
    @Override
    public void call() {
        System.out.println("I am calling by Mi11");
    }
}

class HUAWEIMate40Pro implements Phone {
    @Override
    public void call() {
        System.out.println("I am calling by HUAWEIMate40Pro");
    }
}

class MiTV4s65 implements TV {
    @Override
    public void watchTV() {
        System.out.println("I am watching MiTV4s65");
    }
}

class HAUWEIX70 implements  TV {
    @Override
    public void watchTV() {
        System.out.println("I am watching HUAWEIX70!");
    }
}

建造者模式

思维导图

UML 图

代码实现

下面代码通过将一个复杂产品（手机）的建造交给不同的建造者（小米建造、华为建造）得到不同的产品（小米手机，华为手机），而选择建造者的指挥建造者的是手机生产的流水线（指挥者），选择小米建造者生产小米手机，同理获得华为手机。

  • 消费者 Foxconn：告诉指挥者（流水线）ConstructStream 需要什么手机，然后等待流水线返回手机 Phone 的实例。

  • 指挥者 ConstructStream：根据消费者的需求（传入的手机名称），选择合适的建造者（创建对应实例 MiBuilder HUAWEIBuilder），然后指挥建造者去做自己可以完成的每一道工序（installCPU()…），完成所有步骤之后，让建造者返回手机给自己（getPhone()）。

  • 建造者 Builder：实现了建造手机的所有步骤，不同的建造者用于建造不同的手机，MiBuilder 只能完成 Mi11 的建造。

  • 手机 Phone：单个产品，创建非常复杂，有很多初始化参数，所以交给流水线处理。

建造者关心的是如何一步一步建造 一个 比较复杂的产品（通过建造者完成大量步骤获取产品），而工厂方法关心的是以怎样的方式获取一类产品（比如通过超级工厂获取不同级产品）。

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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
package space.xorex;

public class Foxconn {
    public static void main(String[] args) {
        // 来富士康拿手机
        ConstructStream ConMiPhone=new ConstructStream("Mi11");
        Phone Mi=ConMiPhone.StartConstruct();
        ConstructStream ConHUAWEIPhone=new ConstructStream("HUAWEIMate40Pro");
        Phone HUAWEI=ConHUAWEIPhone.StartConstruct();
    }
}

// 指挥手机生产的流水线（指挥者 Director）,从这里获取手机实例
// 不需要关心如何指挥手机的具体建造者，让流水线（指挥者）管理
class ConstructStream {

    private String PhoneName;
    private Builder worker;

    public ConstructStream(String phoneName) {
        PhoneName = phoneName;
    }

    public Phone StartConstruct() {

        if(PhoneName=="Mi11") worker=new MiBuilder(PhoneName);
        if(PhoneName=="HUAWEIMate40Pro") worker=new HUAWEIBuilder(PhoneName);

        worker.installCPU();
        worker.installGPU();
        worker.installRAM();
        worker.installROM();
        worker.installScreen();
        worker.installBattery();
        worker.installCamera();

        return worker.getPhone();
    }
}

// 抽象建造者，定义建造者需要执行的步骤
interface Builder {

    void installCPU();

    void installGPU();

    void installRAM();

    void installROM();

    void installScreen();

    void installBattery();

    void installCamera();

    Phone getPhone();

}

// 实现的具体建造者，不同建造者获取的产品不同
class MiBuilder implements Builder {

    private Phone phone=null;

    MiBuilder(String PhoneName) {
        phone=new Phone(PhoneName);
        System.out.println(PhoneName+" start making!");
    }

    @Override
    public void installCPU() {
        phone.installCPU("SnapDragon 888");
        System.out.println("Installed CPU : SnapDragon 888");
    }

    @Override
    public void installGPU() {
        phone.installGPU("Adreno 660");
        System.out.println("Install GPU : Adreno 660");

    }

    @Override
    public void installRAM() {
        phone.installRAM("LPDDR5");
        System.out.println("Install RAM : LPDDR5");
    }

    @Override
    public void installROM() {
        phone.installROM("UFS 3.1");
        System.out.println("Install ROM : UFS 3.1");
    }

    @Override
    public void installScreen() {
        phone.installScreen("OLED2k120HZ");
        System.out.println("Install Screen : OLED2k120HZ");
    }

    @Override
    public void installBattery() {
        phone.installBettary("4600mah");
        System.out.println("Install Battery : 4600mah");
    }

    @Override
    public void installCamera() {
        phone.installCarame("HMX");
        System.out.println("Install Camera : HMX");
    }

    @Override
    public Phone getPhone() {
        System.out.println("Mi11 made Successfully!");
        return phone;
    }
}

// 实现的具体建造者，不同建造者获取的产品不同
class HUAWEIBuilder implements Builder{

    private Phone phone=null;

    HUAWEIBuilder(String PhoneName) {
        this.phone = new Phone(PhoneName);
        System.out.println(PhoneName+" start making!");
    }

    @Override
    public void installCPU() {
        phone.installCPU("Kirin9000");
        System.out.println("Install CPU Kirin9000");
    }

    @Override
    public void installGPU() {
        phone.installGPU("Mali-G78");
        System.out.println("Install GPU : Mali-G78");
    }

    @Override
    public void installRAM() {
        phone.installRAM("LPDDR5");
        System.out.println("Install RAM : LPDDR5");
    }

    @Override
    public void installROM() {
        phone.installROM("UFS3.1");
        System.out.println("Install ROM : UFS3.1");
    }

    @Override
    public void installScreen() {
        phone.installScreen("OLED1080P90HZ");
        System.out.println("Install Screen : OLED1080P90HZ");
    }

    @Override
    public void installBattery() {
        phone.installBettary("4400mah");
        System.out.println("Install Battery : 4400mah");
    }

    @Override
    public void installCamera() {
        phone.installCarame("IMX700");
        System.out.println("Install Camera : IMX700");
    }

    @Override
    public Phone getPhone() {
        System.out.println("HUAWEIMate40Pro made Successfully!");
        return phone;
    }
}

// 需要获取的产品实例（流水线指挥不同的建造者生产不同的手机）
class Phone {

    private String Name=null;
    private String CPU=null;
    private String GPU=null;
    private String RAM=null;
    private String ROM=null;
    private String Screen=null;
    private String Bettary=null;
    private String Carame=null;

    public Phone(String name) {
        Name = name;
    }

    public void installCPU(String CPU) {
        this.CPU = CPU;
    }

    public void installGPU(String GPU) {
        this.GPU = GPU;
    }

    public void installRAM(String RAM) {
        this.RAM = RAM;
    }

    public void installROM(String ROM) {
        this.ROM = ROM;
    }

    public void installScreen(String screen) {
        Screen = screen;
    }

    public void installBettary(String bettary) {
        Bettary = bettary;
    }

    public void installCarame(String carame) {
        Carame = carame;
    }
}