Java中怎么拷贝一个对象呢?可以通过调用这个对象类型的构造器构造一个新对象,然后将要拷贝对象的属性设置到新对象里面。Java中也有另一种不通过构造器来拷贝对象的方式,这种方式称为[b]克隆[/b]。
Java提供了java.lang.Cloneable和java.lang.Object中的clone()方法来支持克隆。Cloneable接口表示一种可以克隆的行为或特性,但这个接口中却没有提供clone方法(Cloneable接口中没有任何方法,看起来更像是一个标记接口)。
相反在Object中却存在一个clone方法,这一点很奇怪。
Object中的clone方法为受保护方法。既然所有的对象都存在一个clone方法,那是不是都可以调用(可通过反射)这个方法来得到克隆对象呢?clone方法有如下规定:[color=blue]如果一个对象没有实现Cloneable接口,调用它的clone方法会抛出CloneNotSupportedException异常。但数组例外,可以认为数组实现了Cloneable,所以可以直接调用其clone方法获取克隆对象。[/color]
我们开发中应该怎样使用克隆呢?一般认为,如果希望一个类拥有克隆的行为,要做一下几步:
①该类实现java.lang.Cloneable接口。
②覆盖Object的clone方法,将访问修饰符改为public,修改返回类型。
③clone方法内部调用父类的clone方法。
示例如下:
按照Object克隆方法描述中的规范,克隆得到对象应该独立于被克隆对象,从根本上说,它们的内存地址(不严格的说)应该不同。但是如果有这种情况,一个可克隆类中包含其他的引用类型属性,那么克隆后会是什么情况呢?举个例子说明一下:
运行结果:
可见,虽然克隆对象与被克隆对象内存地址不同,但他们的引用类型属性却指向相同的内存地址。这便涉及到了[b]浅克隆[/b]和[b]深克隆[/b]的问题。
上面的情况就是浅克隆,可见clone方法默认的行为就是浅克隆。那么也很容易想到,如果克隆一个对象,并递归的克隆其所有的引用类型属性,这样的方式就是深克隆了。
对于一个复杂的类,如果需要提供克隆方法的话,一般会先调用父类的clone方法,然后将相应的域(属性)设置为相应的值(有些域需要保存状态,有些域需要清空。)或者将域清空然后调用内部方法来初始化状态,并且要在方法注释上说明该方法的行为是深克隆还是浅克隆。如HashMap的克隆方法:
Java提供了java.lang.Cloneable和java.lang.Object中的clone()方法来支持克隆。Cloneable接口表示一种可以克隆的行为或特性,但这个接口中却没有提供clone方法(Cloneable接口中没有任何方法,看起来更像是一个标记接口)。
package java.lang;
/**
* A class implements the <code>Cloneable</code> interface to
* indicate to the {@link java.lang.Object#clone()} method that it
* is legal for that method to make a
* field-for-field copy of instances of that class.
* <p>
* Invoking Object's clone method on an instance that does not implement the
* <code>Cloneable</code> interface results in the exception
* <code>CloneNotSupportedException</code> being thrown.
* <p>
* By convention, classes that implement this interface should override
* <tt>Object.clone</tt> (which is protected) with a public method.
* See {@link java.lang.Object#clone()} for details on overriding this
* method.
* <p>
* Note that this interface does <i>not</i> contain the <tt>clone</tt> method.
* Therefore, it is not possible to clone an object merely by virtue of the
* fact that it implements this interface. Even if the clone method is invoked
* reflectively, there is no guarantee that it will succeed.
*
* @author unascribed
* @version %I%, %G%
* @see java.lang.CloneNotSupportedException
* @see java.lang.Object#clone()
* @since JDK1.0
*/
public interface Cloneable {
}
相反在Object中却存在一个clone方法,这一点很奇怪。
/**
* Creates and returns a copy of this object. The precise meaning
* of "copy" may depend on the class of the object. The general
* intent is that, for any object <tt>x</tt>, the expression:
* <blockquote>
* <pre>
* x.clone() != x</pre></blockquote>
* will be true, and that the expression:
* <blockquote>
* <pre>
* x.clone().getClass() == x.getClass()</pre></blockquote>
* will be <tt>true</tt>, but these are not absolute requirements.
* While it is typically the case that:
* <blockquote>
* <pre>
* x.clone().equals(x)</pre></blockquote>
* will be <tt>true</tt>, this is not an absolute requirement.
* <p>
* By convention, the returned object should be obtained by calling
* <tt>super.clone</tt>. If a class and all of its superclasses (except
* <tt>Object</tt>) obey this convention, it will be the case that
* <tt>x.clone().getClass() == x.getClass()</tt>.
* <p>
* By convention, the object returned by this method should be independent
* of this object (which is being cloned). To achieve this independence,
* it may be necessary to modify one or more fields of the object returned
* by <tt>super.clone</tt> before returning it. Typically, this means
* copying any mutable objects that comprise the internal "deep structure"
* of the object being cloned and replacing the references to these
* objects with references to the copies. If a class contains only
* primitive fields or references to immutable objects, then it is usually
* the case that no fields in the object returned by <tt>super.clone</tt>
* need to be modified.
* <p>
* The method <tt>clone</tt> for class <tt>Object</tt> performs a
* specific cloning operation. First, if the class of this object does
* not implement the interface <tt>Cloneable</tt>, then a
* <tt>CloneNotSupportedException</tt> is thrown. Note that all arrays
* are considered to implement the interface <tt>Cloneable</tt>.
* Otherwise, this method creates a new instance of the class of this
* object and initializes all its fields with exactly the contents of
* the corresponding fields of this object, as if by assignment; the
* contents of the fields are not themselves cloned. Thus, this method
* performs a "shallow copy" of this object, not a "deep copy" operation.
* <p>
* The class <tt>Object</tt> does not itself implement the interface
* <tt>Cloneable</tt>, so calling the <tt>clone</tt> method on an object
* whose class is <tt>Object</tt> will result in throwing an
* exception at run time.
*
* @return a clone of this instance.
* @exception CloneNotSupportedException if the object's class does not
* support the <code>Cloneable</code> interface. Subclasses
* that override the <code>clone</code> method can also
* throw this exception to indicate that an instance cannot
* be cloned.
* @see java.lang.Cloneable
*/
protected native Object clone() throws CloneNotSupportedException;
Object中的clone方法为受保护方法。既然所有的对象都存在一个clone方法,那是不是都可以调用(可通过反射)这个方法来得到克隆对象呢?clone方法有如下规定:[color=blue]如果一个对象没有实现Cloneable接口,调用它的clone方法会抛出CloneNotSupportedException异常。但数组例外,可以认为数组实现了Cloneable,所以可以直接调用其clone方法获取克隆对象。[/color]
我们开发中应该怎样使用克隆呢?一般认为,如果希望一个类拥有克隆的行为,要做一下几步:
①该类实现java.lang.Cloneable接口。
②覆盖Object的clone方法,将访问修饰符改为public,修改返回类型。
③clone方法内部调用父类的clone方法。
示例如下:
public class CloneableObj implements Cloneable{
//...
@Override
public CloneableObj clone(){
try {
return (CloneableObj) super.clone();
} catch (CloneNotSupportedException e) {
throw new AssertionError();
}
}
}
按照Object克隆方法描述中的规范,克隆得到对象应该独立于被克隆对象,从根本上说,它们的内存地址(不严格的说)应该不同。但是如果有这种情况,一个可克隆类中包含其他的引用类型属性,那么克隆后会是什么情况呢?举个例子说明一下:
public class MyObj implements Cloneable{
private MyPro myPro;
public MyPro getMyPro() {
return myPro;
}
public void setMyPro(MyPro myPro) {
this.myPro = myPro;
}
@Override
public MyObj clone(){
try {
return (MyObj) super.clone();
} catch (CloneNotSupportedException e) {
throw new AssertionError();
}
}
}
public class MyPro {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
public class Test {
public static void main(String[] args) {
MyObj myObj = new MyObj();
MyPro myPro = new MyPro();
myPro.setName("aa");
myObj.setMyPro(myPro);
MyObj clone = myObj.clone();
//myObj和clone是否指向相同的内存地址
System.out.println(clone == myObj);
//myObj的myPro和clone的myPro是否指向相同的内存地址
System.out.println(clone.getMyPro() == myObj.getMyPro());
}
}
运行结果:
false
true
可见,虽然克隆对象与被克隆对象内存地址不同,但他们的引用类型属性却指向相同的内存地址。这便涉及到了[b]浅克隆[/b]和[b]深克隆[/b]的问题。
上面的情况就是浅克隆,可见clone方法默认的行为就是浅克隆。那么也很容易想到,如果克隆一个对象,并递归的克隆其所有的引用类型属性,这样的方式就是深克隆了。
对于一个复杂的类,如果需要提供克隆方法的话,一般会先调用父类的clone方法,然后将相应的域(属性)设置为相应的值(有些域需要保存状态,有些域需要清空。)或者将域清空然后调用内部方法来初始化状态,并且要在方法注释上说明该方法的行为是深克隆还是浅克隆。如HashMap的克隆方法:
/**
* Returns a shallow copy of this <tt>HashMap</tt> instance: the keys and
* values themselves are not cloned.
*
* @return a shallow copy of this map
*/
public Object clone() {
HashMap<K,V> result = null;
try {
result = (HashMap<K,V>)super.clone();
} catch (CloneNotSupportedException e) {
// assert false;
}
result.table = new Entry[table.length];
result.entrySet = null;
result.modCount = 0;
result.size = 0;
result.init();
result.putAllForCreate(this);
return result;
}