原型模式

个人简析

原型模式的理解关键在于Java中深克隆和浅克隆的理解，只要理解了这个基本就理解了原型模式，原型模式就是利用Java的克隆特性先实例化一个对象，然后其他的对象都是通过当前实例化以后的对象克隆得到的，也就是说我们真正需要的对象不再是重新实例化

原型模式中最终使用深克隆还是浅克隆要根据业务需求决定，并没有强制性的要求。还有就是克隆得到的对象与被克隆对象在克隆是的当前状态是一模一样的，克隆不是类的克隆，而是对象状态的克隆；类在编辑的时候生产的，对象是在程序执行的时候生成的，存在于内存当中。

---

<以下主要讲的是Java的克隆相关，理解了克隆就理解了原型模式>

克隆:

Java的clone()方法
⑴clone方法将对象复制了一份并返回给调用者。一般而言，clone（）方法满足：
①对任何的对象x，都有x.clone() !=x//克隆对象与原对象不是同一个对象
②对任何的对象x，都有x.clone().getClass()= =x.getClass()//克隆对象与原对象的类型一样
③如果对象x的equals()方法定义恰当，那么x.clone().equals(x)应该成立。

⑵Java中对象的克隆
①为了获取对象的一份拷贝，我们可以利用Object类的clone()方法。 
②在派生类中覆盖基类的clone()方法，并声明为public。 
③在派生类的clone()方法中，调用super.clone()。 
④在派生类中实现Cloneable接口。

实现类：

/**

 * Created by IntelliJ IDEA.

 * User: leizhimin

 * Date: 2007-9-20

 * Time: 19:40:44

 * 简单类克隆实现

 * 要实现克隆,必须实现Cloneable接口,这是一个标识接口,没有接口方法

 * 实现了 Cloneable 接口，以指示 Object.clone() 方法可以合法地对该类实例进行按字段复制。

 * 按照惯例，实现此接口的类应该使用公共方法重写 Object.clone（它是受保护的）。

 */

public class CloneFooA  implements Cloneable {

    private String strA;

    private int intA;

 

    public CloneFooA(String strA, int intA) {

        this.strA = strA;

        this.intA = intA;

    }

 

    public String getStrA() {

        return strA;

    }

 

    public void setStrA(String strA) {

        this.strA = strA;

    }

 

    public int getIntA() {

        return intA;

    }

 

    public void setIntA(int intA) {

        this.intA = intA;

    }

 

    /**

     * @return 创建并返回此对象的一个副本。

     * @throws CloneNotSupportedException

     */

    public Object  clone() throws  CloneNotSupportedException {

        //直接调用父类的clone()方法,返回克隆副本

         return super.clone();

    }

}

 

 

/**

 * Created by IntelliJ IDEA.

 * User: leizhimin

 * Date: 2007-9-20

 * Time: 19:59:55

 * 深度克隆对象,当类存在聚合关系的时候,克隆就必须考虑聚合对象的克隆

 */

public class CloneFooB  implements Cloneable {

    private  CloneFooA fooA;

    private Double douB;

 

    public CloneFooB(Double douB) {

        this.douB = douB;

    }

 

    public CloneFooB(CloneFooA fooA, Double douB) {

        this.fooA = fooA;

        this.douB = douB;

    }

 

    public CloneFooA getFooA() {

        return fooA;

    }

 

    public void setFooA(CloneFooA fooA) {

        this.fooA = fooA;

    }

 

    public Double getDouB() {

        return douB;

    }

 

    public void setDouB(Double douB) {

        this.douB = douB;

    }

 

    /**

     * 克隆操作

     *

     * @return 自身对象的一个副本

     * @throws CloneNotSupportedException

     */

    public Object clone() throws CloneNotSupportedException {

         //克隆只是一种标示，然后就可以通过Object父类的clone方法进行当前对象的克隆，他只是克隆当前对象变量中的值和其他信息

        CloneFooB cloneFooB = (CloneFooB) super.clone();

         /*

         *关键在这里，上边已经克隆了当前对象的副本，但是这个副本中的引用类型还只是复制了他的引用，接下来就可以通过已经复制到的对象

 *来继续克隆这个复制对象中引用类型的对象，为其分配新的空间。对象是产生于程序运行过程中，并且存在于内存当中。

 *注意这里要判断是否为空，直接克隆可能报错

*/

        if (this.fooA != null)

            cloneFooB.fooA = (CloneFooA) this.fooA.clone();

        return cloneFooB;

    }

}

 

 

/**
 * Created by IntelliJ IDEA.
 * User: leizhimin
 * Date: 2007-9-20
 * Time: 19:52:01
 * 测试类：分别克隆CloneFooA和CloneFooB类,并打印克隆前后的结果.
 */
public class CloneDemo {

    public static void main(String args[]) throws CloneNotSupportedException {

        //CloneFooA克隆前

        CloneFooA fooA1 = new CloneFooA("FooA", 11);

        System.out.println("CloneFooA的对象克隆前对象fooA1值为: " + fooA1.getStrA() + "," + fooA1.getIntA());

        //CloneFooA克隆后

        CloneFooA fooA2 = (CloneFooA) fooA1.clone();

        System.out.println("CloneFooA的对象克隆后对象fooA2值为: " + fooA2.getStrA() + "," + fooA2.getIntA());

        //比较fooA1和fooA2内存地址

        if (fooA1 == fooA2) System.out.println("比较fooA1和fooA2内存地址:相等!");

        else System.out.println("比较fooA1和fooA2内存地址:不相等!");

        System.out.println("-------------------------");

        //CloneFooB克隆前

        CloneFooB fooB1 = new CloneFooB(fooA1, new Double("33"));

        System.out.println("CloneFooB的对象克隆前对象fooB1值为: " + fooB1.getFooA().getStrA() + "," + fooB1.getFooA().getIntA() + " | " + fooB1.getDouB());

        //CloneFooB克隆后

        CloneFooB fooB2 = (CloneFooB) fooB1.clone();

        System.out.println("CloneFooB的对象克隆前对象fooB2值为: " + fooB2.getFooA().getStrA() + "," + fooB2.getFooA().getIntA() + " | " + fooB2.getDouB());

        if (fooA1 == fooA2) System.out.println("比较fooB1和fooB2内存地址:相等!");

        else System.out.println("比较fooB1和fooB2内存地址:不相等!");

    }

}