设计模式-创建型模式-工厂/原型/建造

作者: 石头耳东 | 来源:发表于2022-05-13 21:40 被阅读0次

前言：虽然设计模式是一种经验总结，但实际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

简单工厂模式.png

以上即为简单工厂该有的样子，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

静态工厂模式.png

注意：相比于简单工厂模式，静态工厂模式的具体工厂通过静态方法对外创建具体产品。

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:继承

JDK中的Calendar.png

Ⅰ 抽象产品：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:依赖（使用关系）

工厂方法模式.png

Ⅰ 抽象工厂（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:生产

抽象工厂模式.png

③ 优缺点

优点：

当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。

缺点：

当产品族中需要增加一个新的产品时，所有的工厂类都需要进行修改。

对比三种工厂模式

① 简单工厂&静态工厂

抽象产品 + 具体产品

具体工厂

② 工厂方法模式

抽象产品 + 具体产品

抽象工厂 + 具体工厂（与产品一一对应）

③ 抽象工厂模式

抽象产品 + 具体产品

抽象工厂 + 具体工厂（关联整个产品族）

二、原型模式

① 包含角色

抽象原型类：规定了具体原型对象必须实现的的 clone() 方法
具体原型类：实现抽象原型类的 clone() 方法，它是可被复制的对象
访问类：使用具体原型类中的 clone() 方法来复制新的对象

② 原型模式类图

classDiagram
class Prototype{
    <<Interface>>
    +clone() Prototype
}
class Realizetype{
    +clone() Realizetype
}
Prototype..Realizetype

原型模式.png

克隆

浅克隆：创建一个新对象，新对象的属性和原来对象完全相同，对于非基本类型属性，仍指向原有属性所指向的对象的内存地址。

深克隆：创建一个新对象，属性中引用的其他对象也会被克隆，不再指向原有对象地址。

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

建造者模式.png

Ⅰ 抽象建造者类（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建造者模式

Ⅰ 抽象工厂模式实现对产品家族的创建，一个产品家族是这样的一系列产品：具有不同分类维度的产品组合，采用抽象工厂模式则是不需要关心构建过程，只关心什么产品由什么工厂生产即可；

Ⅱ 建造者模式则是要求按照指定的蓝图建造产品，它的主要目的是通过组装零配件而产生一个新产品。

五、结尾

以上即为设计模式-创建型模式-工厂/原型/建造的全部内容，感谢阅读。

设计模式-创建型模式-工厂/原型/建造

零、本文纲要

一、工厂模式

1. 简单工厂模式（非GOF中23种设计模式）

① 包含角色

② 简单工厂模式类图

补充：静态工厂模式（非GOF中23种设计模式）

JDK中的Calendar

③ 优缺点

2. 工厂方法模式

① 包含角色

② 工厂方法类图

JDK中的ArrayList

③ 优缺点

3. 抽象工厂模式

① 包含角色

② 抽象方法类图

③ 优缺点

对比三种工厂模式

① 简单工厂&静态工厂

② 工厂方法模式

③ 抽象工厂模式

二、原型模式

① 包含角色

② 原型模式类图

克隆

JDK中的ArrayList

③ 使用场景

三、建造者模式

① 包含角色

② 建造者模式类图

JDK中的StringBuilder

③ 使用场景

四、创建型模式对比

① 工厂方法模式VS建造者模式

② 抽象工厂模式VS建造者模式

五、结尾

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

java面试