第一部分说了传值的问题,今天接着来看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();
* 代码就不再写了。
* */
}
}