Java基础——克隆
1、克隆
假设有一个对象object1，在某处又需要一个跟object1一样的实例object2，这两个对象是绝对独立的，不会因为某一个修改另一个随之改变，这样，我们不能直接将对象objec1t的引用赋予object2，object2=object， 这样两个引用仍然指向的是同一个对象，不是两个对象，所以就需要将object1的属性克隆到object2身上
Java中克隆分为两种，浅克隆和深克隆
2、浅克隆
把原型对象中成员变量为值类型的属性都复制给克隆对象，把原型对象中成员变量为引用类型的引用地址也复制给克隆对象
会复制原型对象，但不会复制它所引用的对象
浅克隆只是复制了对象的引用地址，两个对象指向同一个内存地址，所以修改其中任意的值，另一个值都会随之变化
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 {@code x}, 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 {@code true}, but these are not absolute requirements.
* While it is typically the case that:
* <blockquote>
* <pre>
* x.clone().equals(x)</pre></blockquote>
* will be {@code true}, this is not an absolute requirement.
* <p>
* By convention, the returned object should be obtained by calling
* {@code super.clone}. If a class and all of its superclasses (except
* {@code Object}) obey this convention, it will be the case that
* {@code x.clone().getClass() == x.getClass()}.
* <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 {@code super.clone} 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 {@code super.clone}
* need to be modified.
* <p>
* ......
*/
//Object类中的clone()方法
protected native Object clone() throws CloneNotSupportedException;
3、深克隆
将原型对象中的所有类型，无论是值类型还是引用类型，都复制一份给克隆对象，也就是说深克隆会把原型对象和原型对象所引用的对象，都复制一份给克隆对象
深克隆是将对象及值复制过来，两个对象修改其中任意的值另一个值不会改变
实现Cloneable接口并重写Object类中的clone()方法或者实现Serializable接口，通过对对象的序列化、反序列化实现克隆和字节流输出，通过这三种方式可以实现深克隆
Cloneable接口没有任何方法，仅是个标志接口(tagging interface)，若要具有克隆能力，实现Cloneable接口的类必须重写从Object继承来的clone方法，并调用Object的clone方法（见下面Object#clone的定义），重写后的方法应为public的
//Cloneable 接口源码
public interface Cloneable {
}
//重写clone()方法
class CloneClass implements Cloneable{
public Object clone(){
CloneClass o = null;
try{
o = (CloneClass)super.clone();
CloneClass .setAddress(this.address.clone());//引用克隆类型赋值
}catch(CloneNotSupportedException e){
e.printStackTrace();
}
return o;
}
}
如果引用类型中海包括引用类型, 要实现多层克隆会很麻烦, 这使用可以使用序列化和反序列化的方式实现对象的深克隆，把对象写到字节流中的过程是序列化的过程, 而把对象从字节流中读出来的过程是反序列化的过程. 由于Java序列化的过程中, 写在流中的是对象的一个拷贝, 而原对象仍然在JVM中
public class A implements Serializable {
private static final long serialVersionUID = "序列化ID"; //显式声明ID
public Outer Aclone() {
Outer outer = null;
try {
// 将对象序列化成流,因为写在流里的是对象的一个拷贝，而原对象仍然存在于JVM里面
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(this);
// 将流序列化成对象
ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bais);
outer = (Outer) ois.readObject();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
return outer;
}
}
通过字节流实现深克隆：
/**
* 通过字节流实现克隆
*/
static class StreamClone {
public static <T extends Serializable> T clone(People obj) {
T cloneObj = null;
try {
// 写入字节流
ByteArrayOutputStream bo = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bo);
oos.writeObject(obj);
oos.close();
// 分配内存,写入原始对象,生成新对象
ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray());//获取上面的输出字节流
ObjectInputStream oi = new ObjectInputStream(bi);
// 返回生成的新对象
cloneObj = (T) oi.readObject();
oi.close();
} catch (Exception e) {
e.printStackTrace();
}
return cloneObj;
}
}
