原型模式(Prototype)

原型模式顾名思义，以一个对象为原型，进行克隆，复制操作，产生一个和原型相似的对象。下面用的例子是以java中浅拷贝和深拷贝为例。

浅拷贝:被克隆对象的所有变量都与原来对象有相同的值，而所有的对其他对象的引用仍然指向原来的对象。

上面说的很抽象，下面通过简单堆栈图描述:(图与示例代码相对应,man对象在person类中被引用)

深拷贝:被克隆对象的所有变量都与原来的对象有相同的值，除去那些引用其他对象的变量。那些引用其他对象的变量将指向被克隆过的新对象，而不再是原有的那些被引用的对象。

示例代码:

public class Man implements Cloneable{
    private String name;
    private int age;
    Man m;
    public Man(int age,String name){
        this.age = age;
        this.name = name;
    }
    public Object clone(){
        try {
          m  = (Man) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return m;
    }
    public void  setAge(int age){
        this.age = age;
    }
    public void setName(String name){
        this.name = name;
    }
    public int getAge(){
        return age;
    }
    public String getName(){
        return name;
    }
}

public class Person implements Cloneable {
    private int age;
    private String name;
     Man man;
    String address = new String("CQ");
    public Person(int age,String name,Man man){
        this.age = age;
        this.name = name;
        this.man = man;
    }
    /*
     *浅拷贝
     */
    public Person clone(){
        Person person = null;
        try {
            person = (Person) super.clone();
        }catch (CloneNotSupportedException e){
            e.printStackTrace();
        }
        return person;
    }
    /*
     *深拷贝
     */
    public Person deepclone(){
        Person person = null;
        try{
            person = (Person)super.clone();
            person.man = (Man)person.man.clone();//同样拷贝引用的对象
        }catch (CloneNotSupportedException e){
            e.printStackTrace();
        }
        return person;
    }

    public void setAge(int age){
        this.age = age;
    }
    public void setName(String name){
        this.name = name;
    }
    public int getAge(){
        return age;
    }
    public String getName(){
        return name;
    }
    public static void main(String[] args){
        Man man = new Man(1,"Man");
        /*
         *浅拷贝
         */
        System.out.print("拷贝前Man:\n"+"age="+man.getAge()+",name="+man.getName()+"\n");
        Person person = new Person(2,"Person",man);
        System.out.print("拷贝前Person:\n"+"age="+person.getAge()+",name="+person.getName()+"\n");

        Person person1 = person.clone();

        person1.setAge(22);
        person1.setName("Person222");
        person1.man.setAge(11);
        person1.man.setName("Man11");
        System.out.print("拷贝前Man:\n"+"age="+man.getAge()+",name="+man.getName()+"\n");
        System.out.print("拷贝后Man:\n"+"age="+person1.man.getAge()+",name="+person1.man.getName()+"\n");//Man引用拷贝后对值得修改，影响到修改之前的值
        System.out.print("拷贝后Person:\n"+"age="+person1.getAge()+",name="+person1.getName()+"\n");

      /*
       *深拷贝
       */
        System.out.println("=================================================");
        Man mandeep = new Man(1,"Man");
        Person persondeep = new Person(2,"Person",mandeep);
        Person person2 = person.deepclone();
        System.out.print("深拷贝前Man:\n"+"age="+mandeep.getAge()+",name="+mandeep.getName()+"\n");
        System.out.print("深拷贝前Person:\n"+"age="+person.getAge()+",name="+person.getName()+"\n");
        person2.setAge(22);
        person2.setName("Person222");
        person2.man.setAge(11);
        person2.man.setName("Man11");
        System.out.print("深拷贝前Man:\n"+"age="+mandeep.getAge()+",name="+mandeep.getName()+"\n");
        System.out.print("深拷贝后Man:\n"+"age="+man.getAge()+",name="+man.getName()+"\n");
        System.out.print("深拷贝后Person:\n"+"age="+person1.getAge()+",name="+person2.getName()+"\n");
    }
}

实现对象的复制很简单，实现Cloneable接口，然后调用super.clone(),即可实现。上面实现深拷贝时，还可以用串行化实现。注意被克隆对象与克隆出的对象是!=,但是类类型是一样的。
关于java的深克隆和浅克隆详细介绍可参考:http://blog.csdn.net/pony_maggie/article/details/52091588