学习设计模式——创建型模式day02

建造者模式

定义：将一个复杂对象的构建和与它的表示分离，使得同样地构建过程可以创建不同的表示

主要作用：在用户不知道对象建造过程和细节的情况下就可以直接创建复杂对象
用户只需要给定出复杂对象的类型和内容，建造者模式按照顺序创建复杂对象

建造者模式有很多变种，但是最常见的就是链式调用的样子。

//抽象类
public abstract class Builder {
    abstract Builder buildA(String msg); //憨包
    abstract Builder buildB(String msg); //可乐
    abstract Builder buildC(String msg); //薯条
    abstract Builder buildD(String msg); //甜点

    abstract Product  getProduct();

}

//工作者
public class Worker extends Builder {
    private Product product;

    public Worker(){
        product=new Product();
    }

    Builder buildA(String msg) {
        product.setBuildA(msg);
        return this;
    }

    Builder buildB(String msg) {
        product.setBuildB(msg);
        return this;
    }

    Builder buildC(String msg) {
        product.setBuildC(msg);
        return this;
    }

    Builder buildD(String msg) {
        product.setBuildD(msg);
        return this;
    }

    Product getProduct() {
        return product;
    }
}

//产品
public class Product {

    private String BuildA ="汉堡";
    private String BuildB ="可乐";
    private String BuildC ="薯条";
    private String BuildD ="甜点";

    public String getBuildA() {
        return BuildA;
    }

    public void setBuildA(String buildA) {
        BuildA = buildA;
    }

    public String getBuildB() {
        return BuildB;
    }

    public void setBuildB(String buildB) {
        BuildB = buildB;
    }

    public String getBuildC() {
        return BuildC;
    }

    public void setBuildC(String buildC) {
        BuildC = buildC;
    }

    public String getBuildD() {
        return BuildD;
    }

    public void setBuildD(String buildD) {
        BuildD = buildD;
    }

    @Override
    public String toString() {
        return "Product{" +
                "BuildA='" + BuildA + '\'' +
                ", BuildB='" + BuildB + '\'' +
                ", BuildC='" + BuildC + '\'' +
                ", BuildD='" + BuildD + '\'' +
                '}';
    }
}

测试：

public class Test {
    public static void main(String[] args) {
        Builder builder =new Worker();

        Product product=builder.buildA("全家桶").buildB("冰淇淋").getProduct();

        System.out.println(product);
    }
}

结果:

原型模式

原型模式很简单：有一个原型实例，基于这个原型实例产生新的实例，也就是“克隆”了。

Object 类中有一个 clone() 方法，它用于生成一个新的对象，当然，如果我们要调用这个方法，java 要求我们的类必须先实现 Cloneable 接口，此接口没有定义任何方法，但是不这么做的话，在 clone() 的时候，会抛出 CloneNotSupportedException 异常。

java
的克隆是浅克隆，碰到对象引用的时候，克隆出来的对象和原对象中的引用将指向同一个对象。通常实现深克隆的方法是将对象进行序列化，然后再进行反序列化。