23种设计模式之创建型模式

发表于 更新于 阅读次数：

前言

本文主要是介绍5种创建型模式中，除了单例模式外的其他创建型模式，包括建造者模式，工厂模式，抽象工厂模式，原型模式。

1、建造者模式，可以将对象的表现和创建（实现）分离开来，根据不同的创建步骤可以产生不同的对象，而对象的创建也是一次性的，创建后的对象是不可变。

2、工厂模式，根据形式的不同，工厂模式可以分为简单工厂方法模式、多工厂方法模式和抽象工厂方法模式。在简单工厂方法模式中只有一个工厂方法，工厂方法根据不同的条件生产不同的对象。多工厂方法模式，为每一个对象都提供一个工厂方法。抽象工厂方法模式，就是在多工厂方法模式的基础上将每个普通工厂方法变为静态工厂方法。另外，可以使用反射来生产产品。

3、抽象工厂模式，它是工厂模式的进一步抽象，它将产品和工厂都抽象为一个接口，每个具体的工厂生产一种具体的产品。

其实它们的特点是，简单工厂方法模式，用一个方法来生产各种产品。多工厂方法模式，一种对象对应一个方法。抽象工厂方法模式，在多工厂方法模式的基础上，进一步的将每个方法都变为静态的，这样子就不需要创建工厂对象了。抽象工厂模式，它将产品和工厂都进一步抽象为一个类或者接口。

一个方法=》多个方法=》多个静态方法=》抽象类（接口）

4、原型模式，就是从一个已经存在的对象（原型）通过克隆和复制创建一个对象。复制分为浅复制和深复制。

浅复制和深复制的区别：

浅复制：将一个对象复制后，基本数据类型的变量都会重新创建，而引用类型，指向的还是原对象所指向的。
深复制：将一个对象复制后，不论是基本数据类型还有引用类型，都是重新创建的。简单来说，就是深复制进行了完全彻底的复制，而浅复制不彻底。

建造者模式

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
public class BuilderTest {

    private String basic;//地基

    private String wall;//墙

    private String roofed;//楼顶

    private BuilderTest() {}

    private BuilderTest(Builder builder) {
        this.basic = builder.basic;
        this.wall = builder.wall;
        this.roofed = builder.roofed;
    }
    
    public void doSomeThing() {

    }

    public static class Builder {

        private String basic;//地基

        private String wall;//墙

        private String roofed;//楼顶

        public Builder setBasic(String basic) {
            this.basic = basic;
            return this;
        }

        public Builder setWall(String wall) {
            this.wall = wall;
            return this;
        }

        public Builder setRoofed(String roofed) {
            this.roofed = roofed;
            return this;
        }

        public BuilderTest create() {
            BuilderTest builderTest = new BuilderTest(this);
            return builderTest;
        }
    }
}

BuilderTest的构造函数都是私有的，只在Builder中创建它的实例。Builder是一个公开的静态内部类，它的内部成员变量都是私有的，只能调用相对应的setter方法设置，并和BuilderTest中的成员变量是一样的，每个setter方法都是返回Builder自身的，可以链式的调用，当调用create时会将变量传递给BuilderTest和一次性初始化BuilderTest实例。

实际使用：

1
2
3
4
5
6
7
BuilderTest builderTest = new BuilderTest.Builder()
                .setBasic("basic")
                .setWall("wall")
                .setRoofed("roofed")
                .create();

builderTest.doSomeThing();

工厂模式

简单工厂方法模式

规范产品接口：

1
2
3
public interface Product {
    void sayHello();
}

产品类：
ProductA.java

1
2
3
4
5
6
7
public class ProductA implements Product {

    @Override
    public void sayHello() {
        System.out.print("Helle ! My name is ProductA");
    }
}

ProductB.java

1
2
3
4
5
6
7
public class ProductB implements Product {

    @Override
    public void sayHello() {
        System.out.print("Hello, My name is ProductB");
    }
}

简单工厂类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class SimpleFactoryTest {

    public Product createProduct(String name) {
        if("ProductA".equals(name)) {
            return new ProductA();
        } else if("ProductB".equals(name)) {
            return new ProductB();
        } else {
            System.out.print("没有找到产品，请输入正确的类型！");
            return null;
        }
    }

}

使用：

1
2
3
4
5
6
SimpleFactoryTest simpleFactoryTest = new SimpleFactoryTest();
Product productA = simpleFactoryTest.createProduct("ProductA");
productA.sayHello();

Product ProductB = simpleFactoryTest.createProduct("ProductB");
ProductB.sayHello();

多工厂方法模式

MultiMethodFactory.java

1
2
3
4
5
6
7
8
9
10
public class MultiMethodFactory {

    public Product createProductA() {
        return new ProductA();
    }

    public Product createProductB() {
        return new ProductB();
    }
}

使用：

1
2
3
4
5
6
MultiMethodFactory multiMethodFactory = new MultiMethodFactory();
Product productA = multiMethodFactory.createProductA();
productA.sayHello();
        
Product productB = multiMethodFactory.createProductB();
productB.sayHello();

静态工厂方法模式

1
2
3
4
5
6
7
8
9
10
public class StaticMethodFactory {

    public static Product createProductA() {
        return new ProductA();
    }

    public static Product createProductB() {
        return new ProductB();
    }
}

使用：

1
2
3
4
5
Product productA = StaticMethodFactory.createProductA();
Product productB = StaticMethodFactory.createProductB();

productA.sayHello();
productB.sayHello();

抽象工厂模式

产品模版：

1
2
3
public interface Product {
    void sayHello();
}

ProductA.java

1
2
3
4
5
6
7
public class ProductA implements Product {

    @Override
    public void sayHello() {
        System.out.print("Helle ! My name is ProductA");
    }
}

ProductB.java

1
2
3
4
5
6
7
public class ProductB implements Product {

    @Override
    public void sayHello() {
        System.out.print("Hello, My name is ProductB");
    }
}

工厂模版：

1
2
3
public interface Factory {
    Product createProduct();
}

ProductAFactory.java

1
2
3
4
5
6
7
public class ProductAFactory implements Factory {

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

ProductBFactory.java

1
2
3
4
5
6
7
public class ProductBFactory implements Factory {

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

使用：

1
2
3
4
5
ProductAFactory productAFactory = new ProductAFactory();
productAFactory.createProduct();

ProductBFactory productBFactory = new ProductBFactory();
productBFactory.createProduct();

原型模式

原型模式的关键是实现Cloneable接口，并重写Object的clone函数，Cloneable是一个空接口。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class PrototypeObject implements Cloneable {

    public int intValue = 34;

    public String strValue = "I am the First value";

    public ProductA productA = new ProductA();

    @Override
    public Object clone() throws CloneNotSupportedException {
        PrototypeObject prototypeObject = (PrototypeObject)super.clone();
        return prototypeObject;
    }

    @Override
    public String toString() {
        return "intValue=" + intValue
                + "strValue=" + strValue
                + "helloTxt=" + productA.helloTxt;
    }
}

ProductA.java

1
2
3
4
5
6
7
8
9
public class ProductA implements Product {

    public String helloTxt = "Helle ! My name is ProductA";

    @Override
    public void sayHello() {
        System.out.print("Helle ! My name is ProductA");
    }
}

使用：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
try {
    PrototypeObject prototypeObject = new PrototypeObject();
    PrototypeObject prototypeObjectClone =  (PrototypeObject)prototypeObject.clone();

    Log.d("hyj", "改变克隆对象值之前:"
            + "prototypeObject=>" + prototypeObject.toString());

    prototypeObjectClone.strValue = "I am the second value";
    prototypeObjectClone.productA.helloTxt = "Hi, I am here and change something";
    Log.d("hyj", "改变克隆对象值之后:"
            + "prototypeObject=>" + prototypeObject.toString());
    Log.d("hyj", "改变克隆对象值之后:"
            + "prototypeObjectClone=>" + prototypeObjectClone.toString());

} catch (CloneNotSupportedException e) {
    System.out.print(e.getCause());
}

运行结果：

1
2
3
改变克隆对象值之前:prototypeObject=>intValue=34strValue=I am the First valuehelloTxt=Helle ! My name is ProductA
改变克隆对象值之后:prototypeObject=>intValue=34strValue=I am the First valuehelloTxt=Hi, I am here and change something
改变克隆对象值之后:prototypeObjectClone=>intValue=34strValue=I am the second valuehelloTxt=Hi, I am here and change something

在Object中，
Object#clone

1
2
3
4
5
6
7
8
9
10
11
12
13
protected Object clone() throws CloneNotSupportedException {
     if (!(this instanceof Cloneable)) {
         throw new CloneNotSupportedException("Class " + getClass().getName() +
                                                 " doesn't implement Cloneable");
     }

    return internalClone();
}

/*
 * Native helper method for cloning.
 */
private native Object internalClone();

可以看出，Object的clone方法会调用native函数internalClone；

上面提到原型模式是一种浅复制，将一个对象复制后，基本数据类型的变量都会重新创建，而引用类型，指向的还是原对象所指向的。而要彻底重新克隆和创建对象，需要使用深复制。

深复制，可以使用对象的序列化来实现。

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
public class PrototypeObject implements Cloneable, Serializable {

    public int intValue = 34;

    public String strValue = "I am the First value";

    public ProductA productA = new ProductA();

    /* 浅复制 */
    @Override
    public Object clone() throws CloneNotSupportedException {
        PrototypeObject prototypeObject = (PrototypeObject)super.clone();
        return prototypeObject;
    }

    /* 深复制 */
    public Object deepClone() throws IOException, ClassNotFoundException {

        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(this);

        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);
        return ois.readObject();
    }

    @Override
    public String toString() {
        return "intValue=" + intValue
                + "strValue=" + strValue
                + "helloTxt=" + productA.helloTxt;
    }
}