26.如何实现对象克隆？

对象克隆就是对象的复制操作。

分为浅克隆(ShallowClone)和深克隆(DeepClone)

在Java语言中，数据类型分为值类型（基本数据类型）和引用类型，值类型包括int、double、byte、boolean、char等简单数据类型，引用类型包括类、接口、数组等复杂类型。浅克隆和深克隆的主要区别在于是否支持引用类型的成员变量的复制，下面将对两者进行详细介绍。

一、浅克隆：

1. 被复制的类需要实现Clonenable接口（不实现的话在调用clone方法会抛出CloneNotSupportedException异常)， 该接口为标记接口(不含任何方法)

2. 覆盖clone()方法，访问修饰符设为public。方法中调用super.clone()方法得到需要的复制对象。（native为本地方法)

举个例子：

class Student implements Cloneable{  
    private int number;  
  
    public int getNumber() {  
        return number;  
    }  
  
    public void setNumber(int number) {  
        this.number = number;  
    }  
      
    @Override  
    public Object clone() {  
        Student stu = null;  
        try{  
            stu = (Student)super.clone();  
        }catch(CloneNotSupportedException e) {  
            e.printStackTrace();  
        }  
        return stu;  
    }  
}  
public class Test {  
    public static void main(String args[]) {  
        Student stu1 = new Student();  
        stu1.setNumber(12345);  
        Student stu2 = (Student)stu1.clone();  
          
        System.out.println("学生1:" + stu1.getNumber());  
        System.out.println("学生2:" + stu2.getNumber());  
          
        stu2.setNumber(54321);  
      
        System.out.println("学生1:" + stu1.getNumber());  
        System.out.println("学生2:" + stu2.getNumber());  
    }  
}

为了证明原来的学生对象与克隆出来的学生对象不是同一个对象，我们可以做下面的尝试：

System.out.println(stu1 == stu2); // false

输出结果为false，很显然代表不同的对象。

二、深克隆

我们再来看另外一种情况，在学生类中再添加一个地址类。

class Address  {  
      private String add;  
    
      public String getAdd() {  
          return add;  
      }  
    
      public void setAdd(String add) {  
          this.add = add;  
       }  
       
 }  
  
 class Student implements Cloneable{  
     private int number;  
   
     private Address addr;  
       
     public Address getAddr() {  
         return addr;  
     }  
   
     public void setAddr(Address addr) {  
         this.addr = addr;  
      }  
  
     public int getNumber() {  
         return number;  
      }  
   
     public void setNumber(int number) {  
         this.number = number;  
     }  
       
     @Override  
     public Object clone() {  
         Student stu = null;  
         try{  
             stu = (Student)super.clone();  
         }catch(CloneNotSupportedException e) {  
             e.printStackTrace();  
         }  
         return stu;  
     }  
 }  
 public class Test {  
       
     public static void main(String args[]) {  
           
         Address addr = new Address();  
         addr.setAdd("杭州市");  
          Student stu1 = new Student();  
         stu1.setNumber(123);  
         stu1.setAddr(addr);  
           
         Student stu2 = (Student)stu1.clone();  
           
         System.out.println("学生1:" + stu1.getNumber() + ",地址:" + stu1.getAddr().getAdd());  
         System.out.println("学生2:" + stu2.getNumber() + ",地址:" + stu2.getAddr().getAdd());  
     }  
 }

这样看上去貌似没有什么问题，但我们在main方法中试着改变addr实例的地址。

addr.setAdd("西湖区");  
  
System.out.println("学生1:" + stu1.getNumber() + ",地址:" + stu1.getAddr().getAdd());  
System.out.println("学生2:" + stu2.getNumber() + ",地址:" + stu2.getAddr().getAdd());

这时我们发现两个学生的地址都更改了。原因是浅复制只是复制了addr变量的引用，并没有真正的开辟另一块空间，将值复制后再将引用返回给新对象。

所以，为了达到真正的复制对象，而不是纯粹引用复制。我们需要将Address类可复制化，并且修改clone方法，完整代码如下：

package test;  
    
  class Address implements Cloneable {  
      private String add;  
    
      public String getAdd() {  
          return add;  
      }  
    
     public void setAdd(String add) {  
         this.add = add;  
     }  
       
     @Override  
     public Object clone() {  
         Address addr = null;  
         try{  
             addr = (Address)super.clone();  
         }catch(CloneNotSupportedException e) {  
             e.printStackTrace();  
         }  
         return addr;  
     }  
 }  
   
 class Student implements Cloneable{  
     private int number;  
   
     private Address addr;  
       
     public Address getAddr() {  
         return addr;  
     }  
  
     public void setAddr(Address addr) {  
         this.addr = addr;  
     }  
   
     public int getNumber() {  
         return number;  
     }  
   
     public void setNumber(int number) {  
         this.number = number;  
     }  
       
     @Override  
     public Object clone() {  
         Student stu = null;  
         try{  
             stu = (Student)super.clone();   //浅复制  
         }catch(CloneNotSupportedException e) {  
             e.printStackTrace();  
         }  
         stu.addr = (Address)addr.clone();   //深度复制  
         return stu;  
     }  
 }  
 public class Test {  
       
     public static void main(String args[]) {  
           
         Address addr = new Address();  
         addr.setAdd("杭州市");  
         Student stu1 = new Student();  
         stu1.setNumber(123);  
         stu1.setAddr(addr);  
           
         Student stu2 = (Student)stu1.clone();  
           
         System.out.println("学生1:" + stu1.getNumber() + ",地址:" + stu1.getAddr().getAdd());  
         System.out.println("学生2:" + stu2.getNumber() + ",地址:" + stu2.getAddr().getAdd());  
           
         addr.setAdd("西湖区");  
           
         System.out.println("学生1:" + stu1.getNumber() + ",地址:" + stu1.getAddr().getAdd());  
         System.out.println("学生2:" + stu2.getNumber() + ",地址:" + stu2.getAddr().getAdd());  
     }  
 }

这样就真正实现了复制对象的目的。

总结：

浅克隆

在浅克隆中，如果原型对象的成员变量是值类型，将复制一份给克隆对象；如果原型对象的成员变量是引用类型，则将引用对象的地址复制一份给克隆对象，也就是说原型对象和克隆对象的成员变量指向相同的内存地址。

简单来说，在浅克隆中，当对象被复制时只复制它本身和其中包含的值类型的成员变量，而引用类型的成员对象并没有复制。

在Java语言中，通过覆盖Object类的clone()方法可以实现浅克隆。

深克隆

在深克隆中，无论原型对象的成员变量是值类型还是引用类型，都将复制一份给克隆对象，深克隆将原型对象的所有引用对象也复制一份给克隆对象。

简单来说，在深克隆中，除了对象本身被复制外，对象所包含的所有成员变量也将复制。

在Java语言中，如果需要实现深克隆，可以通过覆盖Object类的clone()方法实现，也可以通过序列化(Serialization)等方式来实现。序列化就是将对象写到流的过程，写到流中的对象是原有对象的一个拷贝，而原对象仍然存在于内存中。通过序列化实现的拷贝不仅可以复制对象本身，而且可以复制其引用的成员对象，因此通过序列化将对象写到一个流中，再从流里将其读出来，可以实现深克隆。需要注意的是能够实现序列化的对象其类必须实现Serializable接口，否则无法实现序列化操作。

Java语言提供的Cloneable接口和Serializable接口的代码非常简单，它们都是空接口，这种空接口也称为标识接口，标识接口中没有任何方法的定义，其作用是告诉JRE这些接口的实现类是否具有某个功能，如是否支持克隆、是否支持序列化等。

总结
JAVA对象克隆共有两种形式，三种方法

浅克隆

• 调用clone方法

深克隆

• 递归调用clone方法

• 序列化对象