JAVA && Spring && SpringBoot2.x — 学习目录
1. JAVA的克隆
所有java类的共同父类是
java.lang.Object。所以继承了java.lang.Object类的protected Object clone()方法，可以对对象进行复制。子类也可以重写clone()方法，实现自己的复制逻辑。但是clone()方法有一个问题，只会复制对象的引用——即浅引用。
1.1 克隆满足的条件
clone()方法将对象复制一份并返回给调用者。一般来说，clone()方法满足以下的描述：
- （必须）克隆对象与原对象不是同一个对象，都有：
x.clone()!=x。 - （必须）克隆对象和原对象的类型相同，即Class类型相同。
x.clone().getClass()==x.getClass()。 - （可选）如果对象x的
equals()方法定义其恰当的话，那么x.clone().equals(x)应当成立。
1.2 深克隆和浅克隆
无论是自己实现的克隆方法，还是采用java提供的克隆方法，都存在一个浅度克隆和深度克隆的问题。
浅克隆
只负责克隆值传递的数据（比如基本数据类型以及其封装类型、String类型），而不复制引用类型。即所有的引用类型指向的仍然是原来的对象。深克隆
除了浅克隆要克隆的值外，还负责克隆引用类型的数据。引用指向的是新的对象。深度克隆将要复制的对象内部的引用对象都复制了一份，内部引用对象的复制叫做间接复制。
深克隆的过程中，很可能出现循环引用问题，必须小心处理。
1.3 利用序列化实现深克隆
把对象写到流的过程是序列化(serialzation)过程；而把对象从流中读出来的过程是反序列化(deserialization)过程。此时，写入到流里的是对象的一个拷贝，而原对象仍然存在于JVM里面。
1.4 利用Json实现序列化
1.5 JAVA 的Cloneable接口实现深浅克隆
Cloneable接口没有定义成员。一个类实现Cloneable接口，以指示Object.clone()方法，该方法对该类的实例进行现场复制是合法的。
在不实现Cloneable接口的实例上调用对象的克隆方法会抛出异常CloneNotSupportedException
注意：当一个副本被创建时，并没有调用被复制对象的构造函数。复制仅仅是原对象的一个简单精确的拷贝。
实现Cloneable的类
public class User implements Cloneable{
private String name;
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
由于复制可能引起问题，因此在Object中，clone()方法的访问权限是protected。Object类中的clone方法是浅拷贝，如果是对象，他拷贝的只是这个对象的一个引用，而这个引用仍然指向那个对象，当我们改变这个引用的属性时，原来对象也会跟着改变，这不是我们希望看到的，但是Object类肯定做不到深拷贝，因为Object不知道子类中有哪些引用类型，所以将修饰符定义为protected，这样想要在任何地方调用这个类的clone方法，这个类必须重写clone()方法，并把修饰符修改成public，这样在任何地方都可以调用这个类的clone()方法了。
总体来说：用protected修饰clone()方法，主要是为了让子类去重写它，实现深克隆，以防在其他任何地方随意调用后修改。
1.5.1 Cloneable实现深克隆
上面我们提到，
Object的clone()方法访问权限是protected。原因是clone()方法只会实现浅克隆，强制Object的子类必须重写这个方法（手动实现深克隆），并将访问权限设置为public。那么如何重写clone()方法呢？
@Override
public Object clone() throws CloneNotSupportedException {
Body newBody= (Body) super.clone(); //只是对Body属性的浅复制
newBody.head= (Head) head.clone(); //单独复制head引用的对象
return newBody;
}
super.clone()方法是对对象的浅复制。所以，对于引用属性来说，我们要重写clone()方法，以实现对象的深克隆。其实就像递归一样。
深克隆层级依赖问题：
public class Body implements Cloneable{
private Head head;
public Body() {
}
public Body(Head head) {
this.head = head;
}
@Override
protected Object clone() throws CloneNotSupportedException {
Body newBody= (Body) super.clone(); //只是对Body属性的浅复制
newBody.head= (Head) head.clone(); //单独复制head引用的对象
return newBody;
}
//测试对象
public static void main(String[] args) {
//创建原型对象
Body body=new Body(new Head(new Head.Face()));
try {
Body clone = (Body) body.clone();
//判断是否引用的是同一对象
System.out.println("body对象是否相等："+(body==clone));
System.out.println("head对象是否相等："+(body.head==clone.head));
System.out.println("face对象是否相等："+(body.head.face==clone.head.face));
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
}
}
public class Head implements Cloneable{
public Face face;
public Head() {
}
public Head(Face face) {
this.face = face;
}
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone(); //实现的浅复制
}
static class Face{}
}
执行结果
body对象是否相等：false
head对象是否相等：false
face对象是否相等：true
Body类是否实现了深克隆？其实算是实现。因为Body对象内所引用的其他对象（目前只有Head）都进行了拷贝。也就是说两个独立的Body对象内的head引用已经指向了独立的两个Head对象。但是对于Head对象来说，他们指向的是同一个Face对象，这就说明，其实Body对象还是有一定联系的，并没有完全的独立，这应该说是不彻底的深拷贝。
如何彻底的进行深拷贝：
public class Head implements Cloneable{
public Face face;
public Head() {
}
public Head(Face face) {
this.face = face;
}
@Override
protected Object clone() throws CloneNotSupportedException {
Head head= (Head) super.clone(); //实现的浅复制
head.face= (Face) face.clone(); //继续cloneFace对象
return head;
}
static class Face implements Cloneable{
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
}
我们需要在拷贝Head对象的时候，也将Facee对象拷贝一份就可以了。这需要Face类也实现Clone接口，重新clone()方法。
注：alibaba规范手册：
【推荐】慎用Object的clone方法来拷贝对象
说明：对象的clone方法默认是浅拷贝，若想实现深拷贝需要重写clone方法实现属性对象的拷贝。
推荐阅读
