java clone方法使用详解 - allan taylor

<< String与StringBuffer 的区别 | 首页 | VMware网络设置（WindowsXP+虚拟Ret Hat Linux 9） >>

2009-01-08

java clone方法使用详解 - [java基础]
版权声明：转载时请以超链接形式标明文章原始出处和作者信息及本声明
 http://allantaylor.blogbus.com/logs/33593257.html

Java语言的一个优点就是取消了指针的概念，但也导致了许多程序员在编程中常常忽略了对象与引用的区别，特别是先学c、c++后学java的程序员。并且由于Java不能通过简单的赋值来解决对象复制的问题，在开发过程中，也常常要要应用clone（）方法来复制对象。比如函数参数类型是自定义的类时，此时便是引用传递而不是值传递。以下是一个小例子：
Java代码
1. public class A {
2. public String name;
3. }
```
public class A {
	public String name;
}
```
Java代码
1. public class testClone {
3. public void changeA(A a){
4. a.name="b";
5. }
6. public void changInt(int i){
7. i=i*2+100;
8. }
10. /**
11. * @param args
12. */
13. public static void main(String[] args) {
14. // TODO Auto-generated method stub
15. testClone test=new testClone();
16. A a=new A();
17. a.name="a";
18. System.out.println("before change : a.name="+a.name);
19. test.changeA(a);
20. System.out.println("after change : a.name="+a.name);
21. int i=1;
22. System.out.println("before change : i="+i);
23. test.changInt(i);
24. System.out.println("after change : i="+i);
25. }
27. }
```
public class testClone {
	
	public void changeA(A a){
		a.name="b";
	}
	public void changInt(int i){
		i=i*2+100;
	}
	
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		testClone test=new testClone();
		A a=new A();
		a.name="a";
		System.out.println("before change : a.name="+a.name);
		test.changeA(a);
		System.out.println("after  change : a.name="+a.name);
		int i=1;
		System.out.println("before change : i="+i);
		test.changInt(i);
		System.out.println("after  change : i="+i);
	}

}
```
此时输出的结果是：
Java代码
1. before change : a.name=a
2. after change : a.name=b
3. before change : i=1
4. after change : i=1
```
before change : a.name=a
after  change : a.name=b
before change : i=1
after  change : i=1
```
从这个例子知道Java对对象和基本的数据类型的处理是不一样的。在Java中用对象的作为入口参数的传递则缺省为"引用传递"，也就是说仅仅传递了对象的一个"引用"，这个"引用"的概念同C语言中的指针引用是一样的。当函数体内部对输入变量改变时，实质上就是在对这个对象的直接操作。
除了在函数传值的时候是"引用传递"，在任何用"＝"向对象变量赋值的时候都是"引用传递"，如：
Java代码
1. A a1=new A();
2. A a2=new A();
3. a1.name="a1";
4. a2=a1;
5. a2.name="a2";
6. System.out.println("a1.name="+a1.name);
7. System.out.println("a2.name="+a2.name);
```
		A a1=new A();
		A a2=new A();
		a1.name="a1";
		a2=a1;
		a2.name="a2";
		System.out.println("a1.name="+a1.name);
		System.out.println("a2.name="+a2.name);
```
此时输出的结果是：
Java代码
1. a1.name=a2
2. a2.name=a2
```
a1.name=a2
a2.name=a2
```
如果我们要用a2保存a1对象的数据，但又不希望a2对象数据被改变时不影响到a1。实现clone（）方法是其一种最简单，也是最高效的手段。
下面我们来实现A的clone方法
Java代码
1. public class A implements Cloneable {
2. public String name;
4. public Object clone() {
5. A o = null;
6. try {
7. o = (A) super.clone();
8. } catch (CloneNotSupportedException e) {
9. e.printStackTrace();
10. }
11. return o;
12. }
14. }
```
public class A implements Cloneable {
	public String name;

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

}
```
首先要实现Cloneable接口，然后在重载clone方法，最后在clone()方法中调用了super.clone()，这也意味着无论clone类的继承结构是什么样的，super.clone()直接或间接调用了java.lang.Object类的clone()方法。
Java代码
1. A a1=new A();
2. A a2=new A();
3. a1.name="a1";
4. a2=a1;
5. a2.name="a2";
6. System.out.println("a1.name="+a1.name);
7. System.out.println("a2.name="+a2.name);
```
		A a1=new A();
		A a2=new A();
		a1.name="a1";
		a2=a1;
		a2.name="a2";
		System.out.println("a1.name="+a1.name);
		System.out.println("a2.name="+a2.name);
```
此时输出的结果是：
Java代码
1. a1.name=a1
2. a2.name=a2
```
a1.name=a1
a2.name=a2
```
当Class A成员变量类型是java的基本类型时（外加String类型）,只要实现如上简单的clone（称影子clone）就可以。但是如果Class A成员变量是数组或复杂类型时，就必须实现深度clone。
Java代码
1. public class A implements Cloneable {
2. public String name[];
4. public A(){
5. name=new String[2];
6. }
8. public Object clone() {
9. A o = null;
10. try {
11. o = (A) super.clone();
12. } catch (CloneNotSupportedException e) {
13. e.printStackTrace();
14. }
15. return o;
16. }
17. }
```
public class A implements Cloneable {
	public String name[];
	
	public A(){
		name=new String[2];
	}

	public Object clone() {
		A o = null;
		try {
			o = (A) super.clone();
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
		}
		return o;
	}
}
```
测试代码
Java代码
1. A a1=new A();
2. A a2=new A();
3. a1.name[0]="a";
4. a1.name[1]="1";
5. a2=(A)a1.clone();
6. a2.name[0]="b";
7. a2.name[1]="1";
8. System.out.println("a1.name="+a1.name);
9. System.out.println("a1.name="+a1.name[0]+a1.name[1]);
10. System.out.println("a2.name="+a2.name);
11. System.out.println("a2.name="+a2.name[0]+a2.name[1]);
```
A a1=new A();
A a2=new A();
a1.name[0]="a";
a1.name[1]="1";
a2=(A)a1.clone();
a2.name[0]="b";
a2.name[1]="1";
System.out.println("a1.name="+a1.name);
System.out.println("a1.name="+a1.name[0]+a1.name[1]);
System.out.println("a2.name="+a2.name);
System.out.println("a2.name="+a2.name[0]+a2.name[1]);
```
输出结果：
Java代码
1. a1.name=[Ljava.lang.String;@757aef
2. a1.name=b1
3. a2.name=[Ljava.lang.String;@757aef
4. a2.name=b1
```
a1.name=[Ljava.lang.String;@757aef
a1.name=b1
a2.name=[Ljava.lang.String;@757aef
a2.name=b1
```
看到了吧，a1.name,a2.name的hash值都是@757aef,也就是说影子clone对name数组只是clone他们的地址！解决该办法是进行深度clone。
Java代码
1. public Object clone() {
2. A o = null;
3. try {
4. o = (A) super.clone();
5. o.name=(String[])name.clone();//其实也很简单^_^
6. } catch (CloneNotSupportedException e) {
7. e.printStackTrace();
8. }
9. return o;
10. }
```
public Object clone() {
		A o = null;
		try {
			o = (A) super.clone();
            o.name=(String[])name.clone();//其实也很简单^_^
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
		}
		return o;
	}
```
此时输出结果是：
Java代码
1. a1.name=[Ljava.lang.String;@757aef
2. a1.name=a1
3. a2.name=[Ljava.lang.String;@d9f9c3
4. a2.name=b1
```
a1.name=[Ljava.lang.String;@757aef
a1.name=a1
a2.name=[Ljava.lang.String;@d9f9c3
a2.name=b1
```
需要注意的是Class A存在更为复杂的成员变量时，如Vector等存储对象地址的容器时，就必须clone彻底。
Java代码
1. public class A implements Cloneable {
2. public String name[];
3. public Vector<B> claB;
5. public A(){
6. name=new String[2];
7. claB=new Vector<B>();
8. }
10. public Object clone() {
11. A o = null;
12. try {
13. o = (A) super.clone();
14. o.name==(String[])name.clone();//深度clone
15. o.claB=new Vector<B>();//将clone进行到底
16. for(int i=0;i<claB.size();i++){
17. B temp=(B)claB.get(i).clone();//当然Class B也要实现相应clone方法
18. o.claB.add(temp);
19. }
20. } catch (CloneNotSupportedException e) {
21. e.printStackTrace();
22. }
23. return o;
24. }
历史上的今天：
String与StringBuffer 的区别 2009-01-08
巩固java基础之值传递和引用传递 2009-01-08

随机文章：
String与StringBuffer 的区别 2009-01-08
深入探索高效的Java异常处理框架 2009-01-06
Java中的构造器（构造方法）的调用 2008-12-29
Java中静态变量和非静态变量的初始化顺序 2008-12-29
Java中重载和重写的区别 2008-12-29

收藏到：Del.icio.us
Tag：

引用地址：

allan taylor 发表于17:47:36 | 编辑 | 继续话题 | 转发 | 分享　0

allan taylor

2009-01-08

java clone方法使用详解 - [java基础]

历史上的今天：

随机文章：

搜索

最新日志

最新评论