Java 克隆概念
Java克隆分为深克隆和浅克隆两种类型。
浅复制（浅克隆）
被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之，浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。-
深复制（深克隆） 被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。换言之，深复制把要复制的对象所引用的对象都复制了一遍。
下面两张图形象揭示了深克隆和浅克隆的区别。
clone1.jpg
clone.jpg
实现克隆的方式
1. 实现cloneable接口
所有类都默认继承了object类，object 类中定义有clone（）方法，返回类型：object，修饰符为protect ，子类可用。所以无法对类的变量直接使用clone方法（如：定义了某个类Student，声明变量aStudent并创建了对象，但无法使用aStudent.clone(）)。
protected native Object clone() throws CloneNotSupportedException;
Cloneable 只是一个标志接口而已，用来标志该类是否有克隆功能。
public interface Cloneable {
}
事实上，类 Object 的 clone() 方法首先会检查 this.getClass() 是否实现了 Cloneable 接口。
如果 this.getClass() 没有实现 Cloneable 接口， clone() 就会抛 CloneNotSupportedException 返回。否则就会创建一个类型为 this.getClass() 的对象 other ，并将 this 各 field 的值赋值给 other 的对应 field ，然后返回 other 。
实现clone（）的方法：要通过类中重写clone的方法，修饰符改为public。除此之外，还必须实现Cloneable接口，否则会抛出异常（ ）。Java类库中提供的一些类都可以直接使用clone()方法，是因为都默认实现了cloneable()接口。
clone()的默认实现
class Student implements Cloneable {
String name = null;
int number = 0;
Date date;
public Student(Date date, String name, int number) {
this.date = date;
this.name = name;
this.number = number;
}
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
测试代码：
public static void main(String[] args) throws CloneNotSupportedException {
Student student = new Student(new Date(), "liyice", 0211007760);
Student st = (Student) student.clone();
System.out.println(student.name == st.name);
System.out.println(student.number == st.number);
System.out.println(student.date == st.date);
}
输出结果：
true
true
true
可以看出clone()方法默认的是浅克隆，date()对象并没有实现克隆，而是复制了引用。对clone()方法进行修改，即可实现深度克隆。
@Override
protected Object clone() throws CloneNotSupportedException {
Student studentClone = (Student) super.clone();
studentClone.date = (java.util.Date) this.date.clone();
// 编译错误，String类没有实现clone()方法
//studentClone.name = (String) this.name.clone();
return studentClone;
}
输出结果为：
true
true
false
通过以上的实例可以发现，如果要实现深度克隆，需要自己在clone()方法内部添加实现方法，但是如果类的内部结构比较复杂，有较多的嵌套引用，那么实现起来肯呢个会比较麻烦。
2. 通过序列化与反序化数据流
使用序列化的方式实现深度克隆，要求所有的对象都要实现serializable，包括对象中包含的对象。如果没有实现了serializable接口且无法修改所有的类，则推荐使用第三种方式。
/**
* @param obj 要克隆的对象
* @param <T> 泛型
* @return 克隆的对象
* @throws Exception 如果没有实现seriablizable接口将会抛出异常
*/
public static <T> T copyImplSerializable(T obj) throws Exception {
ByteArrayOutputStream baos = null;
ObjectOutputStream oos = null;
ByteArrayInputStream bais = null;
ObjectInputStream ois = null;
Object o;
//如果子类没有继承该接口，这一步会报错
try {
baos = new ByteArrayOutputStream();
oos = new ObjectOutputStream(baos);
oos.writeObject(obj);
bais = new ByteArrayInputStream(baos.toByteArray());
ois = new ObjectInputStream(bais);
o = ois.readObject();
return (T) o;
} catch (Exception e) {
throw new Exception("对象中包含没有继承序列化的对象");
} finally {
try {
baos.close();
oos.close();
bais.close();
ois.close();
} catch (Exception e2) {
//这里报错不需要处理
}
}
}
对以上方法进行测试，
public static void main(String[] args) throws Exception {
Student student = new Student(new Date(), "liyice", 0211007760);
Student st = copyImplSerializable(student);
System.out.println(Objects.equals(student.name, st.name));
System.out.println(student.number == st.number);
System.out.println(student.date == st.date);
}
输出结果为：
true
true
false
由此可见采用序列化为数据流的方式是深度克隆。
3. 通过序列化为json
由于fastjson在json解析中具有最快的性能，因此本例子采用fastjson对对象进行序列化与反序列化。
/**
* @param obj 要克隆的对象
* @param <T> 对象的类型
* @return 克隆的对象
*/
public static <T> T copyByJson(T obj, Class c){
return (T) JSON.parseObject(JSON.toJSONString(obj), c);
}
创建测试代码
public static void main(String[] args) throws Exception {
Man man = new Man(27,new Date(),"liyice", "male");
Man m = copyByJson(man, Man.class);
System.out.println(man.getName() == m.getName());
System.out.println(man.getSex() == m.getSex());
System.out.println(man.getAge() == m.getAge());
System.out.println(man.getDate() == m.getDate());
}
<b>@TODO
在测试过程中发现了一些问题，一是在序列化的时候要求Javabean中的每个成员变量必须具有set和get方法，不然无法进行序列化，二是要求javabean必须是public的，不然反序列化的时候会抛出异常，目前还不知道原因是什么，留待后面解决。</b>
