原型模式就是通过一个原型对象来表明要创建的对象类型，然后用复制这个原型对象的方法来创建更多同类型的对象。 自己对原型模式简单理解的原理图如下： 具体属性没有添加：  原型模式里面关键点就在一个Cloneable接口和clone方法的重写 下面就通过一个配钥匙的例子简单的写了一个程序，起初一个一个抽象类，这样可以重写clone方法，如果是接口的话就得到子类里面把重写的方法具体声明，这样的话对于程序的复用性不是很好，于是就写了一个抽象的类KeyPrototype然后，写了两个子类继承一个客户端，代码如下： ~~~ package com.designpattern.prototype; public abstract class KeyPrototype implements Cloneable { private String color; private float length; private float thick; @Override protected Object clone() throws CloneNotSupportedException { return super.clone(); } @Override public String toString() { return this.getClass() + " -> Color:" + this.getColor() + " Length:" + this.getLength() + " Thick:" + this.getThick(); } public String getColor() { return color; } public float getLength() { return length; } public float getThick() { return thick; } public void setColor(String color) { this.color = color; } public void setLength(float length) { this.length = length; } public void setThick(float thick) { this.thick = thick; } } ~~~ ~~~ package com.designpattern.prototype; public class CopperKey extends KeyPrototype { } ~~~ ~~~ package com.designpattern.prototype; public class AluminiumKey extends KeyPrototype { } ~~~ ~~~ package com.designpattern.prototype; public class Client { public static void main(String[] args) { KeyPrototype copperkey = new CopperKey(); copperkey.setColor("red"); copperkey.setLength(12); copperkey.setThick(2); System.out.println(copperkey); try { KeyPrototype aluminaumkey = (KeyPrototype) copperkey.clone(); aluminaumkey.setColor("yellow"); aluminaumkey.setLength(10); aluminaumkey.setThick(5); System.out.println(aluminaumkey); } catch (CloneNotSupportedException e) { e.printStackTrace(); } } } ~~~ ~~~ class com.designpattern.prototype.CopperKey -> Color:red Length:12.0 Thick:2.0 class com.designpattern.prototype.CopperKey -> Color:yellow Length:10.0 Thick:5.0 ~~~ 这样就简单对前者进行的复制，很显然他们并不是一个对象，里面关于clone的东西做了一个简单的总结 同时来证明他们确实是两个对象，就是改动里面的属性不互相影响： 首先我创建了一个Dog类 ~~~ package com.note.clone; public class Dog/* implements Cloneable */{ private String color; private String name; public Dog(String name,String color){ this.name = name; this.color = color; } public String getColor() { return color; } public void setColor(String color) { this.color = color; } public String getName() { return name; } public void setName(String name) { this.name = name; } /* @Override protected Object clone() throws CloneNotSupportedException { // TODO Auto-generated method stub return super.clone(); }*/ @Override public String toString() { return this.getClass()+" "+this.getName()+" "+this.getColor(); } } ~~~ 然后写了一个Tom类，其中Tom类里面有私有属性Dog ~~~ package com.note.clone; public class Tom implements Cloneable { private String color; private Dog dog = new Dog("mimi", "yellow");; private String name; @Override protected Object clone() throws CloneNotSupportedException { Tom o = null; o = (Tom)super.clone(); // o.setDog((Dog)o.getDog().clone()); return o; } public String getColor() { return color; } public Dog getDog() { return dog; } public String getName() { return name; } public void setColor(String color) { this.color = color; } public void setDog(Dog dog) { this.dog = dog; } public void setName(String name) { this.name = name; } @Override public String toString() { return this.getClass() + " " + this.getName() + " " + this.getColor() + "\n" + "Dog:" + this.dog; } } ~~~ 然后写了一个People类简单的对上述的两个程序进行测试： ~~~ package com.note.clone; public class People { public static void main(String[] args) { Tom tom = new Tom(); tom.setName("Tom"); tom.setColor("blue"); System.out.println(tom); System.out.println(); try { Tom tylo = (Tom) tom.clone(); tylo.setName("tylo"); tylo.setColor("red"); tylo.getDog().setName("lucky"); tylo.getDog().setColor("green"); System.out.println(tylo); System.out.println(); System.out.println(tom); System.out.println(); Dog dog = tylo.getDog(); dog.setName("hello"); dog.setColor("white"); System.out.println(tylo); System.out.println(); System.out.println(tom); System.out.println(); } catch (CloneNotSupportedException e) { e.printStackTrace(); } } } ~~~ 运行结果如下： ~~~ class com.note.clone.Tom Tom blue Dog:class com.note.clone.Dog mimi yellow class com.note.clone.Tom tylo red Dog:class com.note.clone.Dog lucky green class com.note.clone.Tom Tom blue Dog:class com.note.clone.Dog lucky green class com.note.clone.Tom tylo red Dog:class com.note.clone.Dog hello white class com.note.clone.Tom Tom blue Dog:class com.note.clone.Dog hello white ~~~ 这样很明确的表明了对于这两个对象的属性，自己的属性除了Dog以外都是自己的，没有对着对方的属性的改变而改变，但是Dog属性，两个对象的属性是一样的 那么这里就到了深度克隆 我们把Dog和Tom里注释掉的内容打开再运行People程序，运行结果如下： ~~~ class com.note.clone.Tom Tom blue Dog:class com.note.clone.Dog mimi yellow class com.note.clone.Tom tylo red Dog:class com.note.clone.Dog lucky green class com.note.clone.Tom Tom blue Dog:class com.note.clone.Dog mimi yellow class com.note.clone.Tom tylo red Dog:class com.note.clone.Dog hello white class com.note.clone.Tom Tom blue Dog:class com.note.clone.Dog mimi yellow ~~~ 很明显发现，两个对象的Dog属性也没有互相影响，说明了他们不是用的一个引用，这样也证明了上面的例子，他们分别是一个对象，达到了克隆复用的应用。 在原型模式中，可以动态的添加产品分类，而且对整体结构没有影响。 由于原型模式需要给每一个类都配备一个克隆方法，这就需要在这几类的时候通盘考虑，因为在已有类的基础上来添加clone操作时比较困难的，而且原型模式在实现深层的复制时，需要编写一定量的代码。