假如第一集对你有协助，提过雅雷珍藏哦！

在合作开发、刷题、复试中，他们可能将会碰到将三个第一类的特性表达式到另三个第一类的情形，此种情形就叫作复本。复本与Java缓存内部结构密切相关，比如说Java厚薄复本是很必要性的！

在对象的复本中，许多新手可能将分不清究竟是复本了提及却是复本了第一类。在复本中这儿就分成提及复本、浅复本、深复本展开讲诉。

提及复本

提及复本会聚合三个捷伊第一类提及门牌号，但三个最后对准仍然是同三个第一类。怎样更好的认知提及复本呢？很单纯，就拿他们人而言，一般而言有位联系电话，但相同公开场合、人物形象对他们的用法可能将相同，但他们很确切什么样中文名称都是归属于”我”的！

总之，透过三个标识符实例让我们领略到呵呵(为的是方便快捷就不写get、set等方式)：

class Son { String name; int age; public Son(String name, int age) { this.name = name; this.age = age; } }public class test { public static void main(String[] args) { Son s1 = newSon(“son1”, 12); Son s2 = s1; s1.age = 22; System.out.println(s1); System.out.println(s2); System.out.println(“s1的age:”+ s1.age); System.out.println(“s2的age:” + s2.age); System.out.println(“s1==s2” + (s1 == s2));//相等} }

输出的结果为：

Son@135fbaa4 Son@135fbaa4 s1的age:22 s2的age:22 true

浅复本

怎样创建三个第一类，将目标第一类的内容复制过来而不是直接复本提及呢？

这儿先讲呵呵浅复本，浅复本会创建三个新第一类，新第一类和原第一类本身没有任何关系，新第一类和原第一类不等，但新第一类的特性和老第一类相同。具体可以看如下区别：

假如特性是基本类型(int,double,long,boolean等)，复本的就是基本类型的值；假如特性是提及类型，复本的就是缓存门牌号（即复制提及但不复制提及的第一类），因此假如其中三个第一类改变了这个门牌号，就会影响到另三个第一类。

假如用一那哥来描述呵呵浅复本，它应该是这样的：

怎样实现浅复本呢？也很单纯，就是在需要复本的类上实现Cloneable接口并重写其clone()方式。

@Override protected Object clone() throwsCloneNotSupportedException{ return super.clone(); }

在使用的时候直接调用类的clone()方式即可。具体案例如下：

class Father{ String name;public Father(String name) { this.name=name; } @Override public String toString(){return “Father{“ + “name=” + name + \ + }; } } class Son implements Cloneable { intage; String name; Father father;public Son(String name,int age) { this.age=age; this.name = name; }public Son(String name,int age, Father father) { this.age=age; this.name = name; this.father = father; } @Override public String toString() { return “Son{“ + “age=” + age + “, name=” + name + \ + “, father=” + father + }; } @Override protected Son clone() throws CloneNotSupportedException { return (Son) super.clone(); } } public class test { public static void main(String[] args) throws CloneNotSupportedException { Father f=new Father(“bigFather”); Son s1 = new Son(“son1”,13); s1.father=f; Son s2 = s1.clone(); System.out.println(s1); System.out.println(s2); System.out.println(“s1==s2:”+(s1 == s2));//不相等System.out.println(“s1.name==s2.name:”+(s1.name == s2.name));//相等 System.out.println(); //但他们的Father father 和String name的提及一样 s1.age=12; s1.father.name=“smallFather”;//s1.father提及未变 s1.name=“son222”;//类似 s1.name=new String(“son222”) 提及发生变化 System.out.println(“s1.Father==s2.Father:”+(s1.father == s2.father));//相等 System.out.println(“s1.name==s2.name:”+(s1.name == s2.name));//不相等 System.out.println(s1); System.out.println(s2); } }

运行结果为：

Son{age=13, name=son1, father=Father{name=bigFather}} Son{age=13, name=son1, father=Father{name=bigFather}} s1==s2:falses1.name==s2.name:true//此时相等 s1.Father==s2.Father:true s1.name==s2.name:false//修改提及后不等 Son{age=12, name=son222, father=Father{name=smallFather}} Son{age=13, name=son1, father=Father{name=smallFather}}

不出意外，此种浅复本除了第一类本身相同以外，各个零部件和关系和复本第一类都是相同的，就好像双胞胎一样，是三个人，但其开始的样貌、各种关系(父母亲人)都是相同的。需要注意的是其中name初始==是相等的，是因为初始浅复本它们对准三个相同的String，而后s1.name=”son222″ 则改变提及对准。

深复本

对于上述的问题虽然复本的三个第一类相同，但其内部的一些提及却是相同的，怎么样绝对的复本这个第一类，使这个第一类完全独立于原第一类呢？就使用他们的深复本了。深复本：在对提及数据类型展开复本的时候，创建了三个捷伊第一类，并且复制其内的成员变量。

在具体实现深复本上，这儿提供三个方式，重写clone()方式和序列法。

重写clone()方式

假如使用重写clone()方式实现深复本，那么要将类中所有自定义提及变量的类也去实现Cloneable接口实现clone()方式。对于字符类可以创建三个捷伊字符串实现复本。

对于上述代码，Father类实现Cloneable接口并重写clone()方式。son的clone()方式需要对各个提及都复本一遍。

//Father clone()方式 @Override protectedFatherclone() throws CloneNotSupportedException { return (Father) super.clone(); } //Son clone()方式 @Override protected Son clone() throws CloneNotSupportedException { Son son= (Son) super.clone();//待返回克隆的第一类 son.name=new String(name); son.father=father.clone(); return son; }

其他标识符不变，执行结果如下：

Son{age=13, name=son1, father=Father{name=bigFather}} Son{age=13, name=son1, father=Father{name=bigFather}} s1==s2:false s1.name==s2.name:false s1.Father==s2.Father:false s1.name==s2.name:falseSon{age=12, name=son222, father=Father{name=smallFather}} Son{age=13, name=son1, father=Father{name=bigFather}}

序列化

可以发现此种方式实现了深复本。但此种情形有位问题，假如提及数量或者层数太多了怎么办呢？

不可能将去每个第一类挨个写clone()吧？那怎么办呢？借助序列化啊。

因为序列化后：将二进制字节流内容写到三个媒介（文本或字节数组），然后是从这个媒介读取数据，原第一类写入这个媒介后复本给clone第一类，原第一类的修改不会影响clone第一类，因为clone第一类是从这个媒介读取。

熟悉第一类缓存的知道他们经常将Java第一类缓存到Redis中，然后还可能将从Redis中读取聚合Java第一类，这就用到序列化和反序列化。一般可以将Java第一类存储为字节流或者json串然后反序列化成Java第一类。因为序列化会储存第一类的特性但不会也无法存储第一类在缓存中门牌号相关信息。所以在反序列化成Java第一类时候会重新创建所有的提及第一类。

在具体实现上，自定义的类需要实现Serializable接口。在需要深复本的类(Son)中定义三个函数返回该类第一类：

protected Son deepClone() throws IOException, ClassNotFoundException { Son son=null;//在缓存中创建三个字节数组缓冲区，所有发送到输出流的数据保存在该字节数组中 //默认创建三个大小为32的缓冲区 ByteArrayOutputStream byOut=newByteArrayOutputStream();//第一类的序列化输出 ObjectOutputStream outputStream=new ObjectOutputStream(byOut);//透过字节数组的方式展开传输outputStream.writeObject(this); //将当前student第一类写入字节数组中 //在缓存中创建三个字节数组缓冲区，从输入流读取的数据保存在该字节数组缓冲区ByteArrayInputStream byIn=new ByteArrayInputStream(byOut.toByteArray()); //接收字节数组作为参数展开创建ObjectInputStream inputStream=new ObjectInputStream(byIn); son=(Son) inputStream.readObject(); //从字节数组中读取 returnson; }

使用时候调用他们写的方式即可，其他不变，实现的效果为：

Son{age=13, name=son1, father=Father{name=bigFather}} Son{age=13, name=son1, father=Father{name=bigFather}} s1==s2:false s1.name==s2.name:falses1.Father==s2.Father:false s1.name==s2.name:false Son{age=12, name=son222, father=Father{name=smallFather}} Son{age=13, name=son1, father=Father{name=bigFather}}