某些对象进行创建时可能需要较大的代价，但又需要许多重复对象时，可以利用这种模式去创建。这种模式主要是借助于Cloneable接口来实现的。

简单实现：

public class Product implements Cloneable{
    private String name ;
    private int id;
    private ArrayList<String> list = new ArrayList<>();

    public Product(String name,int id){
        System.out.println("构造函数");
        this.name = name;
        this.id = id;
    }

    public void addItem(String name){
        list.add(name);
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    @Override
    public Product clone() {
        try {
            Product clone = (Product) super.clone();
            clone.id = this.id;
            clone.name = this.name;
            clone.list = this.list;
            return clone;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    @Override
    public String toString() {
        return "name: " + name + " id: " + id + " list: " + list.toString();
    }
}

测试类：

public class test {
    public static void main(String[] args) {
        Product product = new Product("apple",101);
        product.addItem("item1");
        product.addItem("item2");
        Product clone = product.clone();
        clone.setId(102);
        System.out.println(product);
        System.out.println(clone);
    }
}

运行结果：

构造函数
name: apple id: 101 list: [item1, item2]
name: apple id: 102 list: [item1, item2]

可见调用clone并不会执行类的构造函数，而且对拷贝对象的修改不会影响原始对象。接下来我们来改变list的内容，看一下现象:

clone.addItem("item3");
System.out.println(product);
System.out.println(clone);

结果如下：

name: apple id: 101 list: [item1, item2, item3]
name: apple id: 102 list: [item1, item2, item3]

发现原始对象也随之被改变了，这样就违背了原形模式的初衷，这里涉及到深浅拷贝的问题。前面我们做的属于浅拷贝，这种拷贝对于引用类型的对象，只是简单的引用原始对象的字段，并没有进行完全的拷贝。要避免这种现象就要实现深拷贝。可以简单修改clone方法如下：

    @Override
    public Product clone() {
        try {
            Product clone = (Product) super.clone();
            clone.id = this.id;
            clone.name = this.name;
            clone.list = (ArrayList<String>) this.list.clone();
            return clone;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

这里我们在拷贝ArrayList时也调用了他自己的clone方法，继续运行测试类，结果如下：

name: apple id: 101 list: [item1, item2]
name: apple id: 102 list: [item1, item2, item3]

这次就达到我们的目的了。这里也就给我们提一个醒，尽量使用深拷贝，可以预防一些安全性问题，另外我们一些自己定义的类，在拷贝时，也要有自己的clone方法。

最后我们可以简单看一下ArrayList的cone实现：

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);
        }
    }

发现就是简单的想clone自己，然后clone整个数组.