原型模式

原型模式的定义与特点：

用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型相同或相似的新对象。在这里，原型实例指定了要创建的对象的种类。用这种方式创建对象非常高效，根本无须知道对象创建的细节。

原型模式的结构与实现：

由于Java提供了对象的clone() 方法，所以用 Java 实现原型模式很简单。原型模式的克隆分为浅克隆和深克隆，Java 中的 Object 类提供了浅克隆的 clone() 方法，具体原型类只要实现 Cloneable 接口就可实现对象的浅克隆，这里的 Cloneable 接口就是抽象原型类。

浅拷贝：

package prototype;

import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;

import java.util.Date;

/**
 * 浅拷贝羊
 *
 * @author Shaw
 * @date 2020/4/19 15:59
 */
@Getter
@NoArgsConstructor
@AllArgsConstructor
public class Sheep implements Cloneable {
    private String name;
    private Date birthday;

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

package prototype;

import java.util.Date;

/**
 * 原型模式：浅拷贝
 *
 * @author Shaw
 * @date 2020/4/19 16:08
 */
public class Client {
    public static void main(String[] args) throws CloneNotSupportedException {
        Date date = new Date(111111111111L);
        Sheep s1 = new Sheep("sh", date);
        Sheep s2 = (Sheep) s1.clone();

        date.setTime(22222222222L);

        System.out.println(s1);
        System.out.println(s1.getName() + ":" + s1.getBirthday());
        System.out.println(s2);
        System.out.println(s2.getName() + ":" + s2.getBirthday());
    }
}

运行结果：

结果分析：

可以看到，浅拷贝后的Sheep对象的地址是不一样的，但是其内容是一样的。在对date对象做出修改后两只羊的date值都发生了同样的改变。可见，浅拷贝直接将原对象中 的 birthday 的引用值拷贝给新对象的 birthday字段，两只羊使用的是同一个date对象。

深拷贝：

package prototype;

import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;

import java.util.Date;

/**
 * 深拷贝羊
 *
 * @author Shaw
 * @date 2020/4/19 16:12
 */
@Getter
@NoArgsConstructor
@AllArgsConstructor
public class Sheep2 implements Cloneable {
    private String name;
    private Date birthday;

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Object obj = super.clone();

        //添加如下代码实现深拷贝
        Sheep2 s2 = (Sheep2) obj;
        s2.birthday = (Date) this.birthday.clone();

        return s2;
    }
}

package prototype;

import java.util.Date;

/**
 * 原型模式：深拷贝
 *
 * @author Shaw
 * @date 2020/4/19 16:08
 */
public class Client2 {
    public static void main(String[] args) throws CloneNotSupportedException {
        Date date = new Date(111111111111L);
        Sheep2 s1 = new Sheep2("sh", date);
        Sheep2 s2 = (Sheep2) s1.clone();

        date.setTime(22222222222L);

        System.out.println(s1);
        System.out.println(s1.getName() + ":" + s1.getBirthday());
        System.out.println(s2);
        System.out.println(s2.getName() + ":" + s2.getBirthday());
    }
}

运行结果：

 

结果分析：

两只羊的地址是不同的，并且在date对象修改后，仅对S1羊产生了影响，说明S2羊并没有使用S1羊的birthday对象。

结论：

可以得出如下结论：如果想要深拷贝一个对象，这个对象必须要实现 Cloneable 接口，实现 clone 方法，并且在 clone 方法内部，把该对象引用的其他对象也要 clone 一份，这就要求这个被引用的对象必须也要实现 Cloneable 接口并且实现 clone 方法。

原型模式的应用场景

原型模式通常适用于以下场景。

• 对象之间相同或相似，即只是个别的几个属性不同的时候。
• 对象的创建过程比较麻烦，但复制比较简单的时候

new方式创建对象和clone方式创建对象对比： 

package prototype;

/**
 * new方式创建对象和clone方式创建对象的对比
 * 
 * @author Shaw
 * @date 2020/4/19 16:59
 */
public class Client4 {

    private static void testNew() {
        long start = System.currentTimeMillis();
        for (int i = 0; i < 1000; i++) {
            Laptop t = new Laptop();
        }
        long end = System.currentTimeMillis();
        System.out.println("new的创建方式耗时：" + (end - start));
    }

    private static void testClone() throws CloneNotSupportedException {
        long start = System.currentTimeMillis();
        Laptop t = new Laptop();
        for (int i = 0; i < 1000; i++) {
            Laptop temp = (Laptop) t.clone();
        }
        long end = System.currentTimeMillis();
        System.out.println("clone的创建方式耗时：" + (end - start));
    }

    public static void main(String[] args) throws CloneNotSupportedException {
        testNew();
        testClone();
    }
}

class Laptop implements Cloneable {
    Laptop() {
        try {
            //模拟创建对象耗时
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

 结果：

可以看到，clone的方式创建对象比起new的方式可以极大的节省时间。 

原型模式可以与工厂模式搭配使用