深克隆与浅克隆

克隆:

注意：克隆得到的对象跟被复制的对象的当前状态是一样的

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内存地址:不相等!");

    }

}