前言：虽然设计模式是一种经验总结，但实际JDK中也很难纯粹使用某一类型的设计模式。还是功能与实现优先，尽量靠拢即可。
零、本文纲要
- 一、工厂模式
- 简单工厂模式（非GOF中23种设计模式）
补充：静态工厂模式（非GOF中23种设计模式） - 工厂方法模式
- 抽象工厂模式
对比三种工厂模式
- 二、原型模式
- 三、建造者模式
- 四、创建型模式对比
一、工厂模式
1. 简单工厂模式（非GOF中23种设计模式）
① 包含角色
Ⅰ 抽象产品 ：定义了产品的规范，描述了产品的主要特性和功能
Ⅱ 具体产品 ：实现或者继承抽象产品的子类
Ⅲ 具体工厂 ：提供了创建产品的方法，调用者通过该方法来获取产品
② 简单工厂模式类图
classDiagram
class Calendar{
<<abstract>>
-TimeZone zone
-Locale locale
Calendar(TimeZone zone,Locale aLocale)*
}
class CalendarFactory{
-createCalendar(TimeZone zone,Locale aLocale)
}
class BuddhistCalendar{
#Calendar(TimeZone zone, Locale aLocale)
}
class JapaneseImperialCalendar{
#Calendar(TimeZone zone, Locale aLocale)
}
class GregorianCalendar{
#Calendar(TimeZone zone, Locale aLocale)
}
Calendar<|--BuddhistCalendar:继承
Calendar<|--JapaneseImperialCalendar:继承
Calendar<|--GregorianCalendar:继承
CalendarFactory--Calendar
以上即为简单工厂该有的样子，JDK中不是这个样子。
Ⅰ 抽象产品：Calendar类
Ⅱ 具体产品：BuddhistCalendar、JapaneseImperialCalendar、GregorianCalendar类
Ⅲ 具体工厂：Calendar类，提供createCalendar方法来生产具体的产品
补充：静态工厂模式（非GOF中23种设计模式）
classDiagram
class Calendar{
<<abstract>>
-TimeZone zone
-Locale locale
Calendar(TimeZone zone,Locale aLocale)*
}
class CalendarFactory{
-createCalendar(TimeZone zone,Locale aLocale)$
}
class BuddhistCalendar{
#Calendar(TimeZone zone, Locale aLocale)
}
class JapaneseImperialCalendar{
#Calendar(TimeZone zone, Locale aLocale)
}
class GregorianCalendar{
#Calendar(TimeZone zone, Locale aLocale)
}
Calendar<|--BuddhistCalendar:继承
Calendar<|--JapaneseImperialCalendar:继承
Calendar<|--GregorianCalendar:继承
CalendarFactory--Calendar
注意：相比于简单工厂模式，静态工厂模式的具体工厂通过静态方法对外创建具体产品。
JDK中的Calendar
classDiagram
class Calendar{
<<abstract>>
-TimeZone zone
-Locale locale
#Calendar(TimeZone zone,Locale aLocale)
-createCalendar(TimeZone zone,Locale aLocale)$
}
class BuddhistCalendar{
#BuddhistCalendar(TimeZone var1, Locale var2)
}
class JapaneseImperialCalendar{
#JapaneseImperialCalendar(TimeZone zone, Locale aLocale)
}
class GregorianCalendar{
#GregorianCalendar(TimeZone zone, Locale aLocale)
}
Calendar<|--BuddhistCalendar:继承
Calendar<|--JapaneseImperialCalendar:继承
Calendar<|--GregorianCalendar:继承
Ⅰ 抽象产品：Calendar类
Ⅱ 具体产品：BuddhistCalendar、JapaneseImperialCalendar、GregorianCalendar类
Ⅲ 具体工厂：Calendar类，通过aLocale.getUnicodeLocaleType("ca")属性的判断，来生产具体的产品
private static Calendar createCalendar(TimeZone zone,
Locale aLocale)
{
... ...
if (aLocale.hasExtensions()) {
String caltype = aLocale.getUnicodeLocaleType("ca");
if (caltype != null) {
switch (caltype) {
case "buddhist":
cal = new BuddhistCalendar(zone, aLocale);
break;
case "japanese":
cal = new JapaneseImperialCalendar(zone, aLocale);
break;
case "gregory":
cal = new GregorianCalendar(zone, aLocale);
break;
}
}
}
... ...
}
注意：此处稍微特殊的地方，抽象产品与具体工厂为同一个类。
③ 优缺点
优点：
Ⅰ 封装了创建对象的过程，可以通过参数直接获取对象；
Ⅱ 把对象的创建和业务逻辑层分开，如果添加新的对象直接修改工厂类；
缺点：
新增产品需要修改工厂类，违背开闭原则。
2. 工厂方法模式
① 包含角色
Ⅰ 抽象工厂（Abstract Factory）：提供了创建产品的接口，调用者通过它访问具体工厂的工厂方法来创建产品
Ⅱ 具体工厂（ConcreteFactory）：主要是实现抽象工厂中的抽象方法，完成具体产品的创建
Ⅲ 抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能
Ⅳ 具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间一一对应
② 工厂方法类图
classDiagram
class Iterator{
<<Interface>>
+next() Object
+hasNext() boolean
+remove()
}
class ArrayListItr{
+next() Object
+hasNext() boolean
+remove()
}
Iterator<|..ArrayListItr:实现
class Collection{
<<Interface>>
+iterator() Iterator
}
class ArrayList{
+iterator() Iterator
}
Collection<|..ArrayList:实现
ArrayListItr<..ArrayList:依赖（使用关系）
Ⅰ 抽象工厂（Abstract Factory）：Collection
Ⅱ 具体工厂（ConcreteFactory）：ArrayList
Ⅲ 抽象产品（Product）：Iterator
Ⅳ 具体产品（ConcreteProduct）：ArrayListIterator
JDK中的ArrayList
Itr是其私有成员内部类。
private class Itr implements Iterator<E> {
... ...
}
③ 优缺点
优点：
Ⅰ 用户只需要知道具体工厂的名称就可得到所要的产品，无须知道产品的具体创建过程；
Ⅱ 在系统增加新的产品时只需要添加具体产品类和对应的具体工厂类，无须对原工厂进行任何修改，满足开闭原则；
缺点：
每增加一个产品就要增加一个具体产品类和一个对应的具体工厂类，这增加了系统的复杂度。
3. 抽象工厂模式
① 包含角色
Ⅰ 抽象工厂（Abstract Factory）：提供了创建产品的接口，它包含多个创建产品的方法，可以创建多个不同等级的产品
Ⅱ 具体工厂（Concrete Factory）：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建
Ⅲ 抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品
Ⅳ 具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它 同具体工厂之间是多对一的关系
② 抽象方法类图
classDiagram
class AbstractFactory{
<<Abstract>>
+createProductA()* ProductA
+createProductB()* ProductB
}
class FactoryCN{
+createProductA() ProductA
+createProductB() ProductB
}
class FactoryUSA{
+createProductA() ProductA
+createProductB() ProductB
}
AbstractFactory<|--FactoryCN:继承
AbstractFactory<|--FactoryUSA:继承
class ProductA{
<<Interface>>
}
class ProductA01
class ProductA02
ProductA<|..ProductA01:实现
ProductA<|..ProductA02:实现
class ProductB{
<<Interface>>
}
class ProductB01
class ProductB02
ProductB<|..ProductB01:实现
ProductB<|..ProductB02:实现
AbstractFactory--ProductA:生产
AbstractFactory--ProductB:生产
FactoryCN--ProductA01:生产
FactoryCN--ProductB01:生产
FactoryUSA--ProductA02:生产
FactoryUSA--ProductB02:生产
③ 优缺点
优点：
当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。
缺点：
当产品族中需要增加一个新的产品时，所有的工厂类都需要进行修改。
对比三种工厂模式
① 简单工厂&静态工厂
抽象产品 + 具体产品
具体工厂
② 工厂方法模式
抽象产品 + 具体产品
抽象工厂 + 具体工厂（与产品一一对应）
③ 抽象工厂模式
抽象产品 + 具体产品
抽象工厂 + 具体工厂（关联整个产品族）
二、原型模式
① 包含角色
抽象原型类：规定了具体原型对象必须实现的的 clone() 方法
具体原型类：实现抽象原型类的 clone() 方法，它是可被复制的对象
访问类：使用具体原型类中的 clone() 方法来复制新的对象
② 原型模式类图
classDiagram
class Prototype{
<<Interface>>
+clone() Prototype
}
class Realizetype{
+clone() Realizetype
}
Prototype..Realizetype
克隆
浅克隆：创建一个新对象，新对象的属性和原来对象完全相同，对于非基本类型属性，仍指向原有属性所指向的对象的内存地址。
深克隆：创建一个新对象，属性中引用的其他对象也会被克隆，不再指向原有对象地址。
JDK中的ArrayList
Object相当于抽象原型
ArrayList相当于具体原型
public Object clone() {
try {
ArrayList<?> v = (ArrayList<?>) super.clone();
v.elementData = Arrays.copyOf(elementData, size);
v.modCount = 0;
return v;
} catch (CloneNotSupportedException e) {
// this shouldn't happen, since we are Cloneable
throw new InternalError(e);
}
}
③ 使用场景
Ⅰ 对象的创建非常复杂，可以使用原型模式快捷的创建对象。
Ⅱ 性能和安全要求比较高。
三、建造者模式
① 包含角色
Ⅰ 抽象建造者类（Builder）：这个接口规定要实现复杂对象的那些部分的创建，并不涉及具体的部件对象的创建
Ⅱ 具体建造者类（ConcreteBuilder）：实现 Builder 接口，完成复杂产品的各个部件的具体创建方法。在构造过程完成后，提供产品的实例
Ⅲ 产品类（Product）：要创建的复杂对象
Ⅳ 指挥者类（Director）：调用具体建造者来创建复杂对象的各个部分，在指导者中不涉及具体产品的信息，只负责保证对象各部分完整创建或按某种顺序创建
② 建造者模式类图
classDiagram
class String
class Appendable{
<<Interface>>
+append(CharSequence csq, int start, int end) Appendable
}
class AbstractStringBuilder{
<<Abstract>>
+append(CharSequence s, int start, int end) AbstractStringBuilder
}
class StringBuilder{
-AbstractStringBuilder abstractStringBuilder
+append(CharSequence s, int start, int end) StringBuilder
}
Appendable<|..AbstractStringBuilder:实现
StringBuilder..>AbstractStringBuilder:依赖
StringBuilder--String
Ⅰ 抽象建造者类（Builder）：Appendable
Ⅱ 具体建造者类（ConcreteBuilder）：AbstractStringBuilder
Ⅲ 产品类（Product）：String
Ⅳ 指挥者类（Director）：StringBuilder
JDK中的StringBuilder
JDK中的StringBuilder并不是严格的建造者模式。
JDK中AbstractStringBuilder并不是私有属性，但是StringBuilder确实调用了AbstractStringBuilder来构建String，如下：
@Override
public StringBuilder append(CharSequence s, int start, int end) {
super.append(s, start, end);
return this;
}
AbstractStringBuilder中完成append方法，如下：
@Override
public AbstractStringBuilder append(CharSequence s, int start, int end) {
if (s == null)
s = "null";
if ((start < 0) || (start > end) || (end > s.length()))
throw new IndexOutOfBoundsException(
"start " + start + ", end " + end + ", s.length() "
+ s.length());
int len = end - start;
ensureCapacityInternal(count + len);
for (int i = start, j = count; i < end; i++, j++)
value[j] = s.charAt(i);
count += len;
return this;
}
③ 使用场景
Ⅰ 创建的对象较复杂，由多个部件构成，各部件面临着复杂的变化，但构件间的建造顺序是稳定的。
Ⅱ 创建复杂对象的算法独立于该对象的组成部分以及它们的装配方式，即产品的构建过程和最终的表示是独立的。
四、创建型模式对比
① 工厂方法模式VS建造者模式
Ⅰ 工厂方法模式注重的是整体对象的创建方式；
Ⅱ 建造者模式注重的是部件构建的过程，意在通过一步一步地精确构造创建出一个复杂的对象。
② 抽象工厂模式VS建造者模式
Ⅰ 抽象工厂模式实现对产品家族的创建，一个产品家族是这样的一系列产品：具有不同分类维度的产品组合，采用抽象工厂模式则是不需要关心构建过程，只关心什么产品由什么工厂生产即可；
Ⅱ 建造者模式则是要求按照指定的蓝图建造产品，它的主要目的是通过组装零配件而产生一个新产品。
五、结尾
以上即为设计模式-创建型模式-工厂/原型/建造的全部内容，感谢阅读。
