1.为什么需要克隆？
比如有时我们要获得一个非常复杂的对象，与其使用new创建对象再对各个属性赋值，不如直接克隆现有的对象。在java中对于基本类型可以使用"="进行克隆，而对于引用类型却不能这样做。
为什么不能对引用类型直接使用“=”呢？
答：因为java将内存空间分为2块，即堆和栈。在栈中保存基本类型和引用类型的变量，在堆中保存对象。如果使用“=”,将修改引用。此时两个引用变量指向同一个对象，如果其中的一个引用变量进行修改也会改变另一个变量。
举例说明：
光头强-->银行卡<--灰太狼
光头强和灰太狼共同拥有一张银行卡，无论谁向里面存钱，都会对对方产生影响。
2.克隆的错误方式（假克隆）
package test;
public class Test {
public static void main(String[] args) {
Person p = new Person("懒洋洋",10);
System.out.println("克隆前的Person");
System.out.println(p.toString());
Person pClone = p;
//对name和age重新赋值
pClone.name = "光头强";
pClone.age = 80;
System.out.println("克隆后的Person");
System.out.println(pClone.toString());
System.out.println("pClone修改属性后，输出p的信息");
System.out.println(p.toString());
}
}
测试结果：
克隆前的Person
姓名：懒洋洋 年龄：10
克隆后的Person
姓名：光头强 年龄：80
pClone修改属性后，输出p的信息
姓名：光头强 年龄：80
其他知识点：栈中的知识点使用完后会立即被回收，而堆中的对象是由java虚拟机管理的，即使该对象已经不再使用，该内存空间只会在一个不确定的时间被回收
3.Java对象的浅克隆
-
为什么叫浅克隆？
答：因为对基本类型的域（各个属性或方法）的复制是行之有效的，而对于引用类型的域可能会出现错误。但是它避免了“一个引用变量进行修改影响另一个”的问题。
-
需要实现的接口
答：需要实现Cloneable接口，如果不实现这个接口，clone()方法会抛出CloneNotSupportedException异常。
代码测试：
package test;
/**
* 创建一个狗类
*/
public class Dog {
public String dogName;
public String dogBreed;//狗的品种
public Dog(String dogName, String dogType) {
this.dogName = dogName;
this.dogBreed = dogType;
}
public String toString(){
StringBuffer sb = new StringBuffer();
sb.append("狗的名字:"+dogName+",")
.append("狗的品种："+dogBreed);
return sb.toString();
}
}
再创建一个人类：
package test;
/**
* 创建一个人类
* @author hgx
*
*/
public class Person implements Cloneable{
public String name;
public int age;
Dog dog = null;
public Person(){
}
public Person(String name, int age, Dog dog) {
this.name = name;
this.age = age;
this.dog = dog;
}
//实现Cloneable接口，重写clone()方法
public Person clone(){
Person p = null;
try {
p = (Person) super.clone();
} catch (Exception e) {
e.printStackTrace();
}
return p;
}
//每个类都有toString()方法，我们可以对其进行重写
public String toString(){
StringBuffer sb = new StringBuffer();
sb.append("人的名字:"+name+",")
.append("人的年龄："+age+",")
.append("所拥有的狗："+dog);
return sb.toString();
}
}
测试类：
package test;
public class Test {
public static void main(String[] args) {
Dog dog = new Dog("希密士", "哈士奇");
Person p = new Person("懒洋洋", 10, dog);
System.out.println("克隆前的Person");
System.out.println(p.toString());
Person pClone = p.clone();
// 对name和age重新赋值
pClone.name = "光头强";
//对dog进行修改
pClone.dog.dogName = "藏獒";
System.out.println("克隆后的Person");
System.out.println(pClone.toString());
System.out.println("pClone修改属性后，输出p的信息");
System.out.println(p.toString());
}
}
测试结果：
克隆前的Person
人的名字:懒洋洋,人的年龄：10,所拥有的狗：狗的名字:希密士,狗的品种：哈士奇
克隆后的Person
人的名字:光头强,人的年龄：10,所拥有的狗：狗的名字:藏獒,狗的品种：哈士奇
pClone修改属性后，输出p的信息
人的名字:懒洋洋,人的年龄：10,所拥有的狗：狗的名字:藏獒,狗的品种：哈士奇
总结：我们通过结果可以发现，克隆后的pClone虽然修改了name和age属性，但对原来p的属性并没有影响。但当我们对dog这个引用进行修改后，原来p的dog也发生了变化。这也就说明“浅克隆对基本类型的复制小菜一碟，但对于引用类型的不能完全控制，除非我们不对引用类型进行修改”
这就是浅克隆存在的问题。但上有政策，下有对策。遇到深克隆，这些问题都要死掉。
涉及到的其他知识点：StringBuffer，toString()方法
4.java的深克隆
-
为什叫深克隆？
这个问题，在上面我们已经了如指掌了。话不多说，言多必失，看代码。
由于大部分代码相同，所以下面只写改变的地方
代码案例：
1.Dog类的改变：实现Cloneable接口，并重写了clone()方法
//注意不要忘记实现Cloneable
@Override
protected Dog clone(){
Dog dog = null;
try {
dog = (Dog) super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return dog;
}
2.Person类的改变：在clone()方法里添加了Dog类的克隆
@Override
public Person clone(){
Person p = null;
try {
p = (Person) super.clone();
p.dog = dog.clone();
} catch (Exception e) {
e.printStackTrace();
}
return p;
}
测试结果：
克隆前的Person
人的名字:懒洋洋,人的年龄：10,所拥有的狗：狗的名字:希密士,狗的品种：哈士奇
克隆后的Person
人的名字:光头强,人的年龄：10,所拥有的狗：狗的名字:藏獒,狗的品种：哈士奇
pClone修改属性后，输出p的信息
人的名字:懒洋洋,人的年龄：10,所拥有的狗：狗的名字:希密士,狗的品种：哈士奇
总结：结果已经证明我们的目的达到了，随意改变一个克隆都不会影响到原来的类。
注意：通常情况下，克隆对象时都需要使用深克隆，但需要注意的是，要是引用类型中还有引用，就都需要实现Cloneable接口，重写clone()方法。
5.深克隆与浅克隆的区别
代码上的不同：浅克隆只是克隆类实现了Cloneable接口，而深克隆不仅克隆类实现了Cloneable接口，而且克隆类里的引用类型也实现了Cloneable接口。
功能上不同，深克隆解决了浅克隆“不能很好对引用类型的复制”的问题。
6.序列化与对象克隆
1.为什么还要使用序列化进行对象的克隆
如果类有很多类型，而且引用类型里还有引用类型的话，那我们岂不是每个都要重写clone()方法，这样也太麻烦了。所以序列化就是来解决这个难题的。
2.序列化是什么？
序列化，简单的说就像时间漏斗一样，漏斗上面的沙子不停的落下，直到漏完为止。而在java中的序列化对象，就是这样一点一点的将一个对象复制成另一个对象。其实，蛮像3D打印机的。
3.大体过程
利用输出流，将对象以字节的形式写入一个字节数组，然后再通过输入流，从这个字节数组中读出。此时就不需要考虑引用类型的问题了。因为序列化可以说，是从根源入手，从本质上实现克隆。就像水管漏水，只清除水是没有用的，只有把水管关住才行。
生活感悟：所以问题还是要从根源上解决，才可保证万无一失。如果java中年遇到一些难题，我们可以想想在生活中是怎样解决的。
4.需要实现的接口
Serializable接口
5.例子代码
package test;
import java.io.Serializable;
// 创建一个狗类
public class Dog implements Serializable{
public String dogName;
public String dogBreed;//狗的品种
public Dog(String dogName, String dogType) {
this.dogName = dogName;
this.dogBreed = dogType;
}
public String toString(){
StringBuffer sb = new StringBuffer();
sb.append("狗的名字:"+dogName+",")
.append("狗的品种："+dogBreed);
return sb.toString();
}
}
//人类
package test;
/**
* 创建一个人类
*/
public class Person implements Cloneable, Serializable {
public String name;
public int age;
Dog dog = null;
public Person() {
}
public Person(String name, int age, Dog dog) {
this.name = name;
this.age = age;
this.dog = dog;
}
@Override
public Person clone() {
Person p = null;
ByteArrayOutputStream bao = new ByteArrayOutputStream();
try {
ObjectOutputStream oos = new ObjectOutputStream(bao);
oos.writeObject(this);
oos.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
ByteArrayInputStream bis = new ByteArrayInputStream(bao.toByteArray());
try {
ObjectInputStream ois = new ObjectInputStream(bis);
p = (Person) ois.readObject();
ois.close();
} catch (IOException | ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return p;
}
public String toString() {
StringBuffer sb = new StringBuffer();
sb.append("人的名字:" + name + ",").append("人的年龄：" + age + ",").append("所拥有的狗：" + dog);
return sb.toString();
}
}
测试类不变：
测试结果：
克隆前的Person
人的名字:懒洋洋,人的年龄：10,所拥有的狗：狗的名字:希密士,狗的品种：哈士奇
克隆后的Person
人的名字:光头强,人的年龄：10,所拥有的狗：狗的名字:藏獒,狗的品种：哈士奇
pClone修改属性后，输出p的信息
人的名字:懒洋洋,人的年龄：10,所拥有的狗：狗的名字:希密士,狗的品种：哈士奇
注意：序列化对象要求实现Cloneable和Serializable接口，如果类中有引用类型的，则引用类型也需要实现Serializable接口。在效率上，序列化要比深克隆慢一点。
7.选择适当的克隆方式
如果类的各个属性的基本类型和引用类型不会变，则可以使用浅克隆。否则使用深克隆。如果类的结构比较复杂，则使用序列化。
8.transient关键字的应用
1.为什么使用transient关键字？
比如有一些属性，我们不想克隆的新的对象访问到它的值（比如密码），则可以在属性的前面加上transient关键字。这样克隆的时候，虽然变量克隆到新的对象中了，但是其值为null（如果为引用类型）或0（如果为基本类型）。
2.transient注意事项
1. transient只能用来修饰属性，不能修饰方法
2. 如果使用序列化一个类，而这个类中的引用类型又没有实现Serializable接口或者不想对其序列化，则需要使用transient修饰该引用类型