JAVA SE之Cloneable 深拷贝和浅拷贝的区别

对照下面的例子很容易看出：
当一个对象赋值给另一个对象变量时，是相同的引用，公用这个对象实例；
浅拷贝，需要实现Cloneable这个标记接口，然后自行实现clone方法，clone方法的默认就是浅拷贝；注意：当对象中成员变量都是基本类型或者不可变量如String的时候，浅拷贝是安全的。
但是当变量中存在子对象变量的引用时，就需要深拷贝了，因为浅拷贝并不会对子对象进行clone，这样就造成子对象变为共享域，对象和对象副本都会造成它的状态等改变。因此，深拷贝就类似于递归的把对象本身及对象中包含的对象都进行clone。

package learning.copy;

/**
 *@className SuperficialCopy
 *@description ：浅拷贝，当对象本身不含有子对象引用的时候，浅拷贝是安全的 
 * clone方法的默认就是浅拷贝，深拷贝需要自己去实现。
 *@author Wanggd @date 2017年5月27日上午11:20:23
 */
public class SuperficialCopy implements Cloneable{

    String name;
int age;

    SuperficialCopy(String name,int age){
this.age = age;
this.name = name;
    }

@Override
public Object clone() throws CloneNotSupportedException{

        Object o = super.clone();
return o;
    }

public static void main(String[] args) throws CloneNotSupportedException {
        SuperficialCopy obj1 = new SuperficialCopy("Kevin",20);

        SuperficialCopy copyObj = (SuperficialCopy) obj1.clone();
        copyObj.age = 80;
        System.out.println("object1's age = " + obj1.age );
//结果：object1's age = 20

        SuperficialCopy obj2 = obj1;
        obj2.age = 90;
        System.out.println("changed by obj2 object1's age = " + obj1.age );
//changed by obj2 object1's age = 90
    }

}

package learning.copy;

/**
 *@className SuperficialCopyHasObj
 *@description ：浅拷贝，当浅拷贝发生在对象含有子对象引用的时候，浅拷贝就不再是安全的。 
 *@author Wanggd @date 2017年5月27日上午11:21:48
 *
 */
public class SuperficialCopyHasObj implements Cloneable{

private String name;
private int age;
private Inner inner;

    SuperficialCopyHasObj(String name,int age,Inner inner){
this.age = age;
this.name = name;
this.inner = inner;
    }

@Override
public Object clone() throws CloneNotSupportedException{

        Object o = super.clone();
return o;
    }

public static void main(String[] args) throws CloneNotSupportedException {
        SuperficialCopyHasObj obj1 = new SuperficialCopyHasObj("Kevin",20,new Inner("who",66));
        System.out.println("Before object1's inner name = " + obj1.inner.getInnerName() );
//结果：Before object1's inner name = who

        SuperficialCopyHasObj copyObj = (SuperficialCopyHasObj) obj1.clone();
        copyObj.age = 80;
        System.out.println("object1's age = " + obj1.age );
//结果：object1's age = 20

        copyObj.inner.setInnerName("what");
        System.out.println("object1's inner name = " + obj1.inner.getInnerName() );
//object1's inner name = what

    }

}

package learning.copy;

/**
 *@className DeepCopy
 *@description ：深度拷贝，对象本身及包含的对象引用也要clone 
 *@author Wanggd @date 2017年5月27日上午11:19:23
 */
public class DeepCopy implements Cloneable{
private String name;
private int age;
private Inner inner;

    DeepCopy(String name, int age, Inner inner){
this.name = name;
this.age = age;
this.inner = inner;
    }

public Object clone(){
        DeepCopy o = null;
try {
            o = (DeepCopy)super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        o.inner = (Inner)inner.clone();
return o;
    }

public static void main(String[] args) {
        Inner inner = new Inner("I'm inner",10);
        DeepCopy obj1 = new DeepCopy("I'm kevin", 20, inner);

        DeepCopy copyObj = (DeepCopy) obj1.clone();
        copyObj.setAge(88);
        copyObj.inner.setInnerAge(90);
        copyObj.inner.setInnerName("changes");

        System.out.println("obj1's age=" + obj1.age + ",obj1's inner name=" + obj1.inner.getInnerName());
//结果：obj1's age=20,obj1's inner name=I'm inner
    }

public String getName() {
return name;
    }

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

public int getAge() {
return age;
    }

public void setAge(int age) {
this.age = age;
    }

public Inner getInner() {
return inner;
    }

public void setInner(Inner inner) {
this.inner = inner;
    }


}

class Inner implements Cloneable{

private String innerName;
private int innerAge;

    Inner(String innerName, int innerAge){
this.innerAge = innerAge;
this.innerName = innerName;
    }

public String getInnerName() {
return innerName;
    }

public void setInnerName(String innerName) {
this.innerName = innerName;
    }

public int getInnerAge() {
return innerAge;
    }

public void setInnerAge(int innerAge) {
this.innerAge = innerAge;
    }

public Object clone(){
        Object o = null;
try {
            o = super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
return o;
    }

}