关于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();
		 * 代码就不再写了。
		 * */
	}

}