關於java中克隆的學習(二)

第一部分說了傳值的問題，今天接着來看clone的問題。

package dcr.study.test.clone;

import java.util.Date;

/*
 * 在實際編程中我們會遇到一種問題，比如，我們有一個客戶，他每次來訂貨，訂單上的商品幾乎都是一樣的
 * 這時每次去錄入商品，顯然很煩，這個時候，我要參照以往的單據去創建一張新的訂單。然後做些細微的修
 * 改，這樣就不用每次去錄這個客戶的信息和商品。
 * 
 * 這種情況，用簡單的賦值語句，不太好。有很多方法去實現這個需求，但用clone應該是一個比較好的方式。
 * 
 * 
 *  這裏值得注意的是Obj必須實現Cloneable接口，否則在使用clone方法的時候，會報
	java.lang.CloneNotSupportedException異常
	這裏我們發現Cloneable接口是一個抽象接口，是不包含任何方法的
	public abstract interface java.lang.Cloneable {}
	其實這個接口僅僅是一個標誌，而且這個標誌也僅僅是針對Object類中clone()方法的，
	如果clone類沒有實現Cloneable接口，並調用了Object的clone()方法
	（也就是調用了super.Clone()方法），那麼Object的clone()方法就會拋出 
	CloneNotSupportedException異常。 
 * */
public class OrderClone implements Cloneable{
	private String buyer;
	private Date date;
	private int number;
	public String getBuyer() {
		return buyer;
	}
	public void setBuyer(String buyer) {
		this.buyer = buyer;
	}
	public Date getDate() {
		return date;
	}
	public void setDate(Date date) {
		this.date = date;
	}
	public int getNumber() {
		return number;
	}
	public void setNumber(int number) {
		this.number = number;
	}
	
	public Object clone(){
		OrderClone o = null;
		try {
			o = (OrderClone)super.clone();
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
		}
		return o;
	}
}

 

package dcr.study.test.clone;
/*
 * 沒有實現克隆接口
 * */
public class UnCloneA {
	private int i;

	public UnCloneA(int ii) {
		i = ii;
	}

	public void doublevalue() {
		i *= 2;
	}

	public String toString() {
		return Integer.toString(i);
	}
}

 

 

package dcr.study.test.clone;

public class CloneB implements Cloneable {
	public int aInt;
	public UnCloneA unCA = new UnCloneA(123);

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

 

package dcr.study.test.clone;

import java.sql.Date;
/*總結：
   Clone()方法的使用比較簡單，注意如下幾點即可：
a． 什麼時候使用shallow Clone，什麼時候使用deep Clone，這個主要看具體對象的域是什麼性質的，
    基本型別還是reference variable
b． 調用Clone()方法的對象所屬的類(Class)必須implements Clonable接口，否則在調用Clone方法的
    時候會拋出CloneNotSupportedException。如果仔細看你會發現Cloneable接口只是個抽象接口
    並沒有任何方法，他只是個標記。 
 * */
public class OrderTest {
	
	public static void main(String[] args) {
		OrderClone o1= new OrderClone();
		o1.setBuyer("dcriori");
		o1.setDate(new Date(0));
		o1.setNumber(10000);
		
		OrderClone o2 = o1;
		OrderClone o3 = (OrderClone) o1.clone();
		
		o2.setBuyer("sagaris");
		o2.setNumber(20000);
		
		System.out.println("O1  \nBuyer:"+o1.getBuyer()+"\nDate:" 
				+ o1.getDate() + "\nNumber:" + o1.getNumber());
		System.out.println("O2  \nBuyer:"+o2.getBuyer()+"\nDate:" 
				+ o2.getDate() + "\nNumber:" + o2.getNumber());
		System.out.println("O3  \nBuyer:"+o3.getBuyer()+"\nDate:" 
				+ o3.getDate() + "\nNumber:" + o3.getNumber());
		/*
		 * 運行結果：
		 *  O1  
			Buyer:sagaris
			Date:1970-01-01
			Number:20000
			O2  
			Buyer:sagaris
			Date:1970-01-01
			Number:20000
			O3  
			Buyer:dcriori
			Date:1970-01-01
			Number:10000
			
			通過運行結果我們發現 OrderClone o2 = o1;o2是通過賦值創建的對象，o2在改變的時候，把o1也改
			掉了，這不是我們想要的結果。但o3沒有變，說明用clone創建出來的對象，和原來的對象沒指向同一塊
			內存。
			
		 * */
		System.out.println("============================================");
		System.out.println("=============下面是影子克隆的情況===============");
		System.out.println("============================================");
		
		CloneB b1 = new CloneB();
		b1.aInt = 11;
		System.out.println("before clone,b1.aInt = "+ b1.aInt);
		System.out.println("before clone,b1.unCA = "+ b1.unCA);

		CloneB b2 = (CloneB)b1.clone();
		b2.aInt = 22;
		b2.unCA.doublevalue();
		System.out.println("=================================");
		System.out.println("after clone,b1.aInt = "+ b1.aInt);
		System.out.println("after clone,b1.unCA = "+ b1.unCA);
		System.out.println("=================================");
		System.out.println("after clone,b2.aInt = "+ b2.aInt);
		System.out.println("after clone,b2.unCA = "+ b2.unCA); 
		/*    ============================================
			=============下面是影子克隆的情況===============
			============================================
			before clone,b1.aInt = 11
			before clone,b1.unCA = 123
			=================================
			after clone,b1.aInt = 11
			after clone,b1.unCA = 246
			=================================
			after clone,b2.aInt = 22
			after clone,b2.unCA = 246
 		 * 這裏我們發現，類CloneB雖然實現了Cloneable接口，也寫了Clone方法，但是由於使用了其它未
		 * 實現Cloneable接口的類UnCloneA因此在改變b2的unCA的值的時候，把b1的unCA的值也改掉了
		 * 這說明在clone的時候，對於基礎類型沒有什麼問題，但是對於類類型，問題就來了，我們知道它們
		 * 保存的僅僅是對象的引用，這也導致clone後的非基本類型變量和原始對象中相應的變量指向的是同一個對象。
		 * 
		 * 解決這個問題的辦法，就是深度clone，
		 * 其實說起來也很簡單，兩個方法，
		 * 一是把UnCloneA類也實現Cloneable接口，重載clone()方法；
		 * 二是在CloneB的clone()方法中加入一句o.unCA = (UnCloneA)unCA.clone();
		 * 代碼就不再寫了。
		 * */
	}

}