今天要介绍一个概念，对象的克隆。本篇有一定难度，请先做好心理准备。看不懂的话可以多看两遍，还是不懂的话，可以在下方留言，我会看情况进行修改和补充。
克隆，自然就是将对象重新复制一份，那为什么要用克隆呢？什么时候需要使用呢？先来看一个小栗子：
简单起见，我们这里用的是Goods类的简单版本。
public class Goods {
private String title;
private double price;
public Goods(String aTitle, double aPrice){
title = aTitle;
price = aPrice;
}
public void setPrice(double price) {
this.price = price;
}
public void setTitle(String title) {
this.title = title;
}
//用于打印输出商品信息
public void print(){
System.out.println("Title:"+title+" Price:"+price);
}
}然后我们来使用这个类。
public class GoodsTest {
public static void main(String[] args){
Goods goodsA = new Goods("GoodsA",20);
Goods goodsB = goodsA;
System.out.println("Before Change:");
goodsA.print();
goodsB.print();
goodsB.setTitle("GoodsB");
goodsB.setPrice(50);
System.out.println("After Change:");
goodsA.print();
goodsB.print();
}
}我们创建了一个Goods对象赋值给变量goodsA，然后又创建了一个Goods变量，并把goodsA赋值给它，先调用Goods的print方法输出这两个变量中的信息，然后调用Goods类中的setTitle和setPrice方法来修改goodsB中的对象内容，再输出两个变量中的信息，下面是输出：
Before Change:
Title:GoodsA Price:20.0
Title:GoodsA Price:20.0
After Change:
Title:GoodsB Price:50.0
Title:GoodsB Price:50.0这里我们发现了灵异事，我们明明修改的是goodsB的内容，可是goodsA的内容也同样发生了改变，这究竟是为什么呢？别心急，且听我慢慢道来。
在Java语言中，数据类型分为值类型（基本数据类型）和引用类型，值类型包括int、double、byte、boolean、char等简单数据类型，引用类型包括类、接口、数组等复杂类型。使用等号赋值都是进行值传递的，如将一个整数型变量赋值给另一个整数型变量，那么后者将存储前者的值，也就是变量中的整数值，对于基本类型如int,double,char等是没有问题的，但是对于对象，则又是另一回事了，这里的goodsA和goodsB都是Goods类对象的变量，但是它们并没有存储Goods类对象的内容，而是存储了它的地址，也就相当于C++中的指针，如果对于指针不了解，那我就再举个栗子好了。我们之前举过一个栗子，把计算机比作是仓库管理员，内存比作是仓库，你要使用什么类型的变量，就需要先登记，然后管理员才会把东西给你，但如果是给你分配一座房子呢？这时候不是把房子搬起来放到登记簿粒，而是登记下房子的地址，这里的地址就是我们的类对象变量里记录的内容，所以，当我们把一个类对象变量赋值给另一个类对象变量，如goodsB = goodsA时，实际上只是把A指向的对象地址赋值给了B，这样B也同样指向这个地址，所以这时候，goodsA和goodsB操作的是同一个对象。
所以，如果只是简单的赋值的话，之后对于goodsA和goodsB的操作都将影响同一个对象，这显然不是我们的本意。也许你还会问，直接再new一个对象不就好了，确实如此，但有时候，如果我们需要保存一个goodsA的副本，那就不仅仅要new一个对象，还需要进行一系列赋值操作才能将我们的新对象设置成跟goodsA对象一样，而且Goods类越复杂，这个操作将会越繁琐，另外使用clone方法还进行本地优化，效率上也会快很多，总而言之，就是简单粗暴。
那如何使用克隆呢？这里我们就要介绍我们牛逼哄哄的Object类了，所有的类都是Object类的子类，虽然我们并没有显式声明继承关系，但所有类都难逃它的魔掌，它有两个protected方法，其中一个就是clone方法。
下面我来展示一波正确的骚操作：
//要使用克隆方法需要实现Cloneable接口
public class Goods implements Cloneable{
private String title;
private double price;
public Goods(String aTitle, double aPrice){
title = aTitle;
price = aPrice;
}
public void setPrice(double price) {
this.price = price;
}
public void setTitle(String title) {
this.title = title;
}
public void print(){
System.out.println("Title:"+title+" Price:"+price);
}
//这里重载了接口的clone方法
@Override
protected Object clone(){
Goods g = null;
//这里是异常处理的语句块，可以先不用了解，只要知道是这样使用就好，之后的文章中会有详细的介绍
try{
g = (Goods)super.clone();
}catch (CloneNotSupportedException e){
System.out.println(e.toString());
}
return g;
}
}其实修改的地方只有两个，一个是定义类的时候实现了Cloneable接口，关于接口的知识在之后会有详细说明，这里只要简单理解为是一种规范就行了，然后我们重载了clone方法，并在里面调用了父类也就是（Object）的clone方法。可以看到我们并没有new一个新的对象，而是使用父类的clone方法进行克隆，关于try catch的知识这里不做过多介绍，之后会有文章做详细说明，这里只需要理解为try语句块里是一个可能发生错误的代码，catch会捕获这种错误并进行处理。
接下来我们再使用这个类的克隆方法：
public class GoodsTest {
public static void main(String[] args){
Goods goodsA = new Goods("GoodsA",20);
Goods goodsB = (Goods)goodsA.clone();
System.out.println("Before Change:");
goodsA.print();
goodsB.print();
goodsB.setTitle("GoodsB");
goodsB.setPrice(50);
System.out.println("After Change:");
goodsA.print();
goodsB.print();
}
}我们仅仅是把赋值改成了调用goodsA的clone方法并进行类型转换。输出如下：
Before Change:
Title:GoodsA Price:20.0
Title:GoodsA Price:20.0
After Change:
Title:GoodsA Price:20.0
Title:GoodsB Price:50.0看，这样不就达到我们目的了吗？是不是很简单？
但是别高兴的太早，关于克隆，还有一点内容需要介绍。
克隆分为浅克隆和深克隆。我们上面使用的只是浅克隆，那两者有什么区别呢？这里再举一个栗子，使用的是简化版的Cart类：
public class Cart implements Cloneable{
//实例域
Goods goodsList = new Goods("",0);//简单起见，这里只放了一个商品
double budget = 0.0;//预算
//构造函数
public Cart(double aBudget){
budget = aBudget;
}
//获取预算
public double getBudget() {
return budget;
}
//修改预算
public void setBudget(double aBudget) {
budget = aBudget;
}
//这里只是简单的将商品进行了赋值
public void addGoods(Goods goods){
goodsList = (Goods) goods.clone();
}
//这是为了演示加上的代码，仅仅将商品标题修改成新标题
public void changeGoodsTitle(String title){
goodsList.setTitle(title);
}
//打印商品信息
public void print(){
System.out.print("Cart内的预算信息："+budget+" 商品信息：");
goodsList.print();
}
//重载clone方法
@Override
protected Object clone(){
Cart c = null;
try{
c = (Cart)super.clone();
}catch (CloneNotSupportedException e ){
e.printStackTrace();
}
return c;
}
}这里将goodsList由数组改成了单个对象变量，仅仅用于演示方便，还增加了一个changeGoodsTitle方法，用于将商品的标题修改成另一个标题，接下来修改一下GoodsTest类：
public class GoodsTest {
public static void main(String[] args){
Goods goodsA = new Goods("GoodsA",20);//新建一个商品对象
Cart cartA = new Cart(5000);//新建一个购物车对象
cartA.addGoods(goodsA);//添加商品
Cart cartB = (Cart) cartA.clone();//使用浅克隆
//输出修改前信息
System.out.println("Before Change:");
cartA.print();
cartB.print();
//修改购物车A中的商品标题
cartA.changeGoodsTitle("NewTitle");
//重新输出修改后的信息
System.out.println("After Change:");
cartA.print();
cartB.print();
}
}输出信息：
Before Change:
Cart内的预算信息：5000.0 商品信息：Title:GoodsA Price:20.0
Cart内的预算信息：5000.0 商品信息：Title:GoodsA Price:20.0
After Change:
Cart内的预算信息：5000.0 商品信息：Title:NewTitle Price:20.0
Cart内的预算信息：5000.0 商品信息：Title:NewTitle Price:20.0我们发现，虽然我们调用的是cartA中的方法修改购物车A中的商品信息，但购物车B中的信息同样被修改了，这是因为使用浅克隆模式的时候，成员变量如果是对象等复杂类型时，仅仅使用的是值拷贝，就跟我们之前介绍的那样，所以cartB虽然是cartA的一个拷贝，但是它们的成员变量goodsList却共用一个对象，这样就藕断丝连了，显然不是我们想要的效果，这时候就需要使用深拷贝了，只需要将Cart类的clone方法修改一下即可：
@Override
protected Object clone(){
Cart c = null;
try{
c = (Cart)super.clone();
c.goodsList = (Goods) goodsList.clone();//仅仅添加了这段代码，将商品对象也进行了克隆
}catch (CloneNotSupportedException e ){
e.printStackTrace();
}
return c;
}现在再来运行一下：
Before Change:
Cart内的预算信息：5000.0 商品信息：Title:GoodsA Price:20.0
Cart内的预算信息：5000.0 商品信息：Title:GoodsA Price:20.0
After Change:
Cart内的预算信息：5000.0 商品信息：Title:NewTitle Price:20.0
Cart内的预算信息：5000.0 商品信息：Title:GoodsA Price:20.0这样就得到了我们想要的结果了。
这样，对象的拷贝就讲完了吗？
哈哈哈哈，不要崩溃，并没有，还有一种更复杂的情况，那就是当你的成员变量里也包含引用类型的时候，比如Cart类中有一个CartB类的成员变量，CartB类中同样存在引用类型的成员变量，这时候，就存在多层克隆的问题了。这里再介绍一个骚操作，只需要了解即可，那就是序列化对象。操作如下：
import java.io.*;
public class Cart implements Serializable{
//实例域
Goods goodsList = new Goods("",0);//简单起见，这里只放了一个商品
double budget = 0.0;//预算
//构造函数
public Cart(double aBudget){
budget = aBudget;
}
//获取预算
public double getBudget() {
return budget;
}
//修改预算
public void setBudget(double aBudget) {
budget = aBudget;
}
//这里只是简单的将商品进行了赋值
public void addGoods(Goods goods){
goodsList = (Goods) goods.clone();
}
//这是为了演示加上的代码，仅仅将商品标题修改成新标题
public void changeGoodsTitle(String title){
goodsList.setTitle(title);
}
//打印商品信息
public void print(){
System.out.print("Cart内的预算信息："+budget+" 商品信息：");
goodsList.print();
}
//这里是主要是骚操作
public Object deepClone() throws IOException, OptionalDataException,ClassNotFoundException {
// 将对象写到流里
ByteArrayOutputStream bo = new ByteArrayOutputStream();
ObjectOutputStream oo = new ObjectOutputStream(bo);
oo.writeObject(this);
// 从流里读出来
ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray());
ObjectInputStream oi = new ObjectInputStream(bi);
return (oi.readObject());
}