java clone方法使用详解

最新推荐文章于 2023-12-15 20:51:44 发布
最新推荐文章于 2023-12-15 20:51:44 发布
阅读量473 收藏
点赞数
分类专栏： java学习
java clone方法使用详解

 

----------------------------------------我是小小分割线--------------------------------

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 { 
  2.      
  3.     public void changeA(A a){ 
  4.         a.name="b"; 
  5.     } 
  6.     public void changInt(int i){ 
  7.         i=i*2+100; 
  8.     } 
  9.      
  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.     } 
  26.  
  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; 
  3.  
  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.     } 
  13.  
  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[]; 
  3.      
  4.     public A(){ 
  5.         name=new String[2]; 
  6.     } 
  7.  
  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; 
  4.      
  5.     public A(){ 
  6.         name=new String[2]; 
  7.         claB=new Vector<B>(); 
  8.     } 
  9.  
  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.     } 
  25. } 
强子rojon
关注
专栏目录
java clone
08-08
对java clone的一些讲解，以及我个人的一些心得等等，
Java clone方法详解及简单实例
08-31
`clone`方法是Java `Object`类中的一个`protected`方法，这意味着在使用`clone`时，需要考虑以下几个关键点： 1. **什么是`clone`**： 当我们需要创建一个已有对象的精确副本时，就可以使用`clone`方法。它不是...
java的clone方法
HD243608836的博客
03-07 369
java的clone有两种方式： 1). 实现Cloneable接口并重写clone()方法，也可以实现深度克隆； 参看：https://www.cnblogs.com/acode/p/6306887.html 2). 实现Serializable接口，通过对象的序列化和反序列化实现克隆，可以实现真正的深度克隆。 参看：https://blog.csdn.net/HD243608836/art...
Java的clone方法
百川
01-21 1105
什么是"clone"？  　　在实际编程过程中，我们常常要遇到这种情况：有一个对象A，在某一时刻A中已经包含了一些有效值，此时可能 会需要一个和A完全相同新对象B，并且此后对B任何改动都不会影响到A中的值，也就是说，A与B是两个独立的对象，但B的初始值是由A对象确定的。在 Java语言中，用简单的赋值语句是不能满足这种需求的。要满足这种需求虽然有很多途径，但实现clone（）方法是其中最简单
Java中的clone方法
zzdnb的博客
04-03 1301
分配完内存之后，再调用构造函数，填充对象的各个域，这一步叫做对象的初始化，构造方法返回后，一个对象创建完毕，可以把他的引用（地址）发布到外部，在外部就可以使用这个引用操纵这个对象（当然，由于指令的重排序，发布对象可能在构造函数返回之前，详细看。都是分配内存，调用clone方法时，分配的内存和源对象（即调用clone方法的对象）相同，然后再使用源对象中对应的各个域，填充新对象的域， 填充完成之后，clone方法返回，一个新的相同的对象被创建，同样可以把这个新对象的引用发布到外部。
Java中的clone方法详解_动力节点Java学院整理
08-30
Java中的clone方法详解 在Java语言中，clone方法是一个非常重要的概念，它允许对象被复制，从而创造出一个新的对象。下面我们将详细介绍Java中的clone方法，并讨论它的实现机制和应用场景。 什么是clone方法 ...
Java 数组复制clone方法实现详解
08-25
本文将深入讲解如何使用`clone()`方法来实现数组复制，并通过实例代码分析其工作原理和注意事项。 首先，`clone()`方法是Java中的一个内置功能，它允许我们创建一个对象的浅拷贝。对于基本类型的数组，`clone()`会...
java 中clone()的使用方法
08-29
Java 中 clone() 的使用方法 Java 中的 clone() 方法是对象的复制方法，其主要作用是创建一个与原对象相同的新对象。下面将详细介绍 Java 中 clone() 方法的使用方法。 什么是 clone() 方法？ clone() 方法是 ...
Java的clone()方法
最新发布
2301_76947341的博客
12-15 806
如果两个Person对象的name的地址值相同， 说明两个对象的name都指向同一个String对象， 也就是浅拷贝， 而如果两个对象的name的地址值不同， 那么就说明指向不同的String对象， 也就是在拷贝Person对象的时候， 同时拷贝了name引用的String对象， 也就是深拷贝。如果只是用Object中默认的clone方法，是浅拷贝的。深拷贝：根据Person源对象中的name指向的字符串对象创建一个新的相同的字符串对象，将这个新字符串对象的引用赋给新拷贝的Person对象的name字段。
java clone 方法
kfyong的专栏
02-15 601
他是原型模式的典型例子； 该方法是复制字节码，底层是用了C，直接读字节流完成，并没走构造方法、执行创建对象和赋值操作。 但是简单的clone方法，是只能针对java的八大数据类型和String来做的， 其他类型没办法直接clone成功，比如list，如果clone时，虽然数据可以在新的实例中显示 但是他并没生成新的对象，依然指向被克隆的对象地址； 这种就是我们说的浅克隆；   深克隆...
Java中的clone()方法
热门推荐
yygr的博客
01-12 1万+
clone()方法的约定 Cloneable接口的目的是作为对象的一个混合接口，表明这样的对象允许克隆（clone），但是这个接口却没有定义clone()，这是它的缺陷：无法约束子类实现clone()方法。Object定义了一个受保护的clone()方法。Cloneable虽然没有定义clone()方法，但是却影响了Object.clone()方法的行为：如果一个类实现了Cloneable，调用Object的clone()就会返回该对象的逐域拷贝，否则抛出CloneNotSupportedException
java中clone方法_java中的clone 方法
weixin_26907223的博客
03-07 328
java的序列化和反序列化;定义:序列化是指把一个对象写到一个输出流中;对象的反序列化是指从一个输入流中读取一个对象.只要实现了java.io.Serializable(标识接口)接口的对象才能被序列化和反序列化;序列化的步骤:1).创建一个对象输出流,它可以包装一个其他类型的输出流,比如文件输出流.ObjectOutputStream out=new ObjectOutputStream(new...
java中的clone()方法
深深的蓝
02-19 419
功能 创建并返回一个本对象的复制。复制的精确定义依赖于各个类的实现，一般来说，有： x.clone() != x x.clone().getClass() == x.getClass() x.clone().equals(x) 说明 Object的clone()方法是protect作用域的，需要在我们的类中实现Cloneable接口，重写覆盖Object的clone()方法，并把其作用域改为...
java的clone方法_Java中的clone()方法
weixin_39906499的博客
02-12 91
不同之处在于您可以修改克隆的对象而不修改原始对象.Point p = new Point(1,2);Point p2 = p.clone();Point p3 = p;p2.x = 5;p3.y = 7;p3上的更改反馈到p,而p2上的更改不会反馈到p.让我们看看个别陈述后的情况(假设1,2,5,7将是对象)：Point p = new Point(1,2);.-----. .-----.p...
java 中的clone方法 ，详解
ssdut_209的博客
07-06 504
转自 :http://www.2cto.com/kf/201401/273852.html Java中对象的创建 clone顾名思义就是复制， 在Java语言中， clone方法被对象调用，所以会复制对象。所谓的复制对象，首先要分配一个和源对象同样大小的空间，在这个空间中创建一个新的对象。那么在java语言中，有几种方式可以创建对象呢？  1 使用new操作符创建一个对象
Java中克隆万物的Clone方法！
KnightHONG的博客
07-21 351
Hello，大家好，我是洪爵呀！今天想和大家聊一下Java的Object类中的Clone方法，它有什么用，我自己new一个不行吗？ ​ 不知道大家有没有用过这个方法，洪爵在面试的时候，经常被问到Object中有哪些方法？常常答不出来呀，因此苦恼，所以决定好好专研下Object里的方法，一个个抓出来！ ​ 我们先来看一下clone源码： public class Object { protected native Object clone() throws CloneNotSupportedExce.
java中clone方法_深入浅出| java中的clone方法
weixin_30965253的博客
02-19 289
每天进步一丢丢,连接梦与想我们还年轻,但这不是你浪费青春的理由克隆和复制clone,有人称之为克隆,有人称之为复制,其实都是同一个东西本文称之为"克隆",毕竟人家方法名叫"clone"为什要用克隆想一想,为什么需要克隆?为什么不重新new一个?道理很简单,目的是想要两个相同的对象,重新new一个还得自己重新赋值,太麻烦如何克隆一个对象？如果是个初学者,可能会这么写publicclassStud...
Java Clone方法详解与应用技巧
Cloneable接口是一个标记接口，没有任何的方法，它的作用就是告诉Java虚拟机，这个类的对象可以使用clone方法进行拷贝。然后，需要重写clone方法，使其返回当前类的对象，而不是Object对象。" "clone方法的实现方式...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值