★★ Java clone 详解(重点关注)

现在的位置: 首页 > 综合 > 正文

RSS

★★ Java clone 详解(重点关注)

2014年11月25日 ⁄ 综合 ⁄ 共 6782字 ⁄ 字号小中大 ⁄ 评论关闭

拷贝对象要细心

url: http://lsy.javaeye.com/blog/46189

在说对象的拷贝问题之前，先提一下java对参数的传递。在Java语言中通过值传递
机制将所有实参的值传递给方法，这就意味着方法将接受所有实参
的一个拷贝，看下面的代码：

Java代码

public

static

void

main(String[] args) {
int

i = 1

;
int

j = 2

;
change(i,j);
System.out.println(i+j);
}
public

static

void

change(int

i, int

j){
i += 10

;
j += 10

;
}

	public static void main(String[] args) {
		int i = 1;
		int j = 2;
		change(i,j);
		System.out.println(i+j);
	}
	public static void change(int i, int j){
		i += 10;
		j += 10;
	}

打印结果是3，并不会影响到原来的变量值。但是如果方法接受的实参类型不是基本类型的变量，而是对象，那么Java语言运用的机制就是引用传递
。继续看代码：
先定义两个Dog类：

Java代码

public

class

Flea{
private

String size;
public

Flea(String size) {
this

.size = size;
}
}
public

class

Dog {
private

String name;
private

int

age;
private

Flea flea;
public

Dog(String aName,int

age) {
this

.name = aName;
this

.age = age;
this

.flea = new

Flea("small"

);
}
public

String toString(){
return

"Dog age is "

+age+"! Dog's flea size is "

+flea.getSize();
}
}

public class Flea{
	private String size;
	public Flea(String size) {
		this.size = size;
	}
}
public class Dog {
	private String name; 
	private int age; 	
	private Flea flea;
	public Dog(String aName,int age) { 
		this.name = aName; 
		this.age = age; 
		this.flea = new Flea("small");		
	}
	public String toString(){
		return "Dog age is "+age+"! Dog's flea size is "+flea.getSize();
	}
}

接着

Java代码

public

static

void

main(String[] args) {
Dog dog = new

Dog("Tom"

,10

);
change(dog);
System.out.println(dog);
}
public

static

void

change(Dog dog){
dog.setAge(100

);
dog.getFlea().setSize("big"

);
}

	public static void main(String[] args) {
		Dog dog = new Dog("Tom",10);
		change(dog);
		System.out.println(dog);
	}
	public static void change(Dog dog){
		dog.setAge(100);
		dog.getFlea().setSize("big");
	}

打印结果应该是Dog age is 100 ! Dog's flea size is big。这是因为传递给方法的变量是一个对象引用的副本，也就是说dog是一个对象的引用，而传递给方法的是dog这个引用的副本，因此二者引用的是同一个对象，因此在方法中对象改变了，那么方法外对象也会改变。这是要做的事情就是在对象传递给方法之前先做拷贝。因此修改一下Dog.java

Java代码

public

class

Flea implements

Cloneable {
private

String size;
public

Flea(String size) {
this

.size = size;
}
public

Object clone() {
Flea newFlea = null

;
try

{
newFlea = super

.clone();
}
catch

(CloneNotSupportedException e){}
return

newFlea;
}
}
public

class

Dog implements

Cloneable{
private

String name;
private

int

age;
public

Dog(String aName, int

age) {
this

.name = aName;
this

.age = age;
this

.flea = new

Flea("small"

);
}
public

Object clone() {
Dog newDog = null

;
try

{
newDog = super

.clone();
}
catch

(CloneNotSupportedException e){}
return

newDog;
}
public

String toString(){
return

"Dog age is "

+age+"! Dog's flea size is "

+flea.getSize();
}
}

public class Flea implements Cloneable {
	private String size;
	public Flea(String size) {
		this.size = size;
	}
	public Object clone() {
		Flea newFlea = null;
		try{
			newFlea = super.clone();
		}
		catch(CloneNotSupportedException e){}
		return newFlea;
	}
}
public class Dog implements Cloneable{
	private String name; 
	private int age; 	
	public Dog(String aName, int age) { 
		this.name = aName; 
		this.age = age; 	
		this.flea = new Flea("small");
	}
	public Object clone() {
		Dog newDog = null;
		try{
			newDog = super.clone();
		}
		catch(CloneNotSupportedException e){}
		return newDog;
	}
	public String toString(){
		return "Dog age is "+age+"! Dog's flea size is "+flea.getSize();
	}
}

接下来调整一下测试代码：

Java代码

public

static

void

main(String[] args) {
Dog dog = new

Dog("Tom"

,10

);
Dog cDog = (Dog)dog.clone();
change(dog);
System.out.println(dog);
System.out.println(cDog);
}

	public static void main(String[] args) {
		Dog dog = new Dog("Tom",10);
		Dog cDog = (Dog)dog.clone();
		change(dog);
		System.out.println(dog);
		System.out.println(cDog);
	}

可以看到打印结果是:
Dog age is 100! Dog's flea size is big
Dog age is 10! Dog's flea size is big
这时结果仍然不能让人满意，因为虽然Dog的age被保留了下来，但是Dog的Flea的size确仍然被改变了。这就是需要注意的地方，拷贝对象时留意对象的嵌套对象的拷贝，如此修改一下Dog的clone方法：

Java代码

public

Object clone() {
Dog newDog = null

;
try

{
newDog = (Dog)super

.clone();
newDog.flea = (Flea)flea.clone();//加上这一行
}
catch

(CloneNotSupportedException e){}
return

newDog;
}

	public Object clone() {
		Dog newDog = null;
		try{
			newDog = (Dog)super.clone();
			newDog.flea = (Flea)flea.clone();//加上这一行
		}
		catch(CloneNotSupportedException e){}
		return newDog;
	}

再次运行一次，可以看到结果是：
Dog age is 100! Dog's flea size is big
Dog age is 10! Dog's flea size is small
这样就可以保留在调用方法之前的对象了。^_^

java中的clone机制

http://blog.csdn.net/hdy007/archive/2007/03/01/1518300.aspx

java中有两种clone方式，一种是浅拷贝，一种是深拷贝．
Object 定义了clone方法,而且定义为protected保护型，返回Object.

如果你要使自定义的类能够被clone,就必须实现Cloneable接口并且
重写clone()方法．

class CloneTest1() implements Cloneable
{
java.util.Date date;
public Object clone()
{
try {
return super.clone();
}
catch (CloneNotSupportedException ex) {
　　　　//如果没有实现Cloneable接口，抛出异常
return null;
}
　　｝
}

CloneTest1简单的实现了Clone()方法，只是简单的调用Object的clone()方法．
这种方式属于浅拷贝，只是clone了CloneTest1的表层．测试如下：
CloneTest1 src=new CloneTest1();
CloneTest1 des=(CloneTest1)src.clone();
System.out.println(src==des); //false 说明有两个CloneTest1的实例．
System.out.println(src.date==des.date); //true 指向相同的数据成员．

有时候我们需要一个完全的备份，就是深层次的拷贝

class CloneTest2 implements Cloneable{
java.util.Date date;
public Object clone(){
try {
   CloneTest2 ct=(CloneTest2)super.Clone();
   ct.date=date.clone();

   return ct;
}
catch (CloneNotSupportedException ex) {
return null;
}
}
}

上面的实现就是一个深拷贝了，要实现深拷贝类中的数据成员都得是Cloneable的(当然
你也可以不是，那就是自找麻烦):
class NotCloneable{
public String str;
}
class CloneTest3{
NotCloneable nc;
public clone(){
try
{
CloneTest3 ct=(CloneTest3)super.clone();
ct.nc=new NotCloneable();
ct.nc.str=str;
return ct;
}
catch (CloneNotSupportedException ex) {
return null;
}
}
}
这样虽然也实现了深拷贝，但是非常不好．

JAVA Clone机制

url: http://onlylove.javaeye.com/blog/265113

1，什么是Clone ？

简单地说， Clone
就是对于给定的一个对象实例 o

，得到另一个对象实例 o’
： o
与 o’
类

型相同（ o.getClass() == o’.getClass()

），内容相同（对于 o/o’
中的字段 f
，如果 f

是基本数据类型，则 o.f == o’.f
；如果
f
是对象引用，则 o.f ==
o’.f
或 o.f
指向的对象与 o’.f
指向的对象的内容相同）。通常称 o’

为 o
的克隆或副本。

2，什么时候使用Clone？

当需要修改对象属性，又不想影响原来的属性值，这时候就应该使用clone了。

3，

Java

对 clone
的支持

万类之初的 Object 类有 clone() 方法：
protected native Object
clone() throws CloneNotSupportedException;
该方法是 protected 的，显然是留待被子类 override
的。该方法又是 native 的，必然做了
与具体平台相关的底层工作。
事实上，类 Object 的 clone() 方法首先会检查
this.getClass() 是否实现了 Cloneable 接口。

Cloneable
只是一个标志接口而已，用来标志该类是否有克隆功能。
public interface Cloneable {

}
     如果
this.getClass() 没有实现 Cloneable 接口， clone() 就会抛 CloneNotSupportedException
返回
。否则就会创建一个类型为 this.getClass() 的对象 other ，并将 this 各 field 的值赋值给 other 的对应 field
，然后返回 other 。
     如此一来，我们要定义一个具有 Clone 功能的类就相当方便：
     1. 在类的声明中加入“
implements Cloneable ”，标志该类有克隆功能；
     2. Override 类 Object 的 clone()
方法，在该方法中调用 super.clone() ：

4，shallow clone and deep clone

Clone是如何完成的呢？Object在对某个对象实施Clone时对其是一无所知的，它仅仅是简单地执行域对域的copy，这就是Shallow
Clone。Java Collection
类库中具体数据结构类（ ArrayList/LinkedList
， HashSet/TreeSet
， HashMap/TreeMap
等）都具有克隆功能，且都是 Shallow Clone。在有种情况下，这种shallow
Clone就会问题，这个情况就是当，要clone的对象中的某个属性是一个引用，

这样克隆类就和原始类共享了一部分信息，对这个属性操作就会影响原始类，所以就需要deep clone.

举例见：http://onlylove.javaeye.com/blog/265113

【上篇】★★ js闭包
【下篇】ora-22992 通过DBLINK 访问远程CLOB表问题

作者: slowdown

该日志由 slowdown 于9年前发表在综合分类下，最后更新于 2014年11月25日.
转载请注明: ★★ Java clone 详解(重点关注) | 学步园 +复制链接

抱歉!评论已关闭.

学步园