Java对象的深克隆与浅克隆（对象复制）（上）

2022-05-11 11:26:39

想复制一个简单变量，很简单：

int apples = 5;  
int pears = apples;

基本数据类型都适用。

但若复制的是个对象，就有点复杂了。

先看段代码：

@Data
class Student {  
   private int number;       
}

public class Test {  
     
   public static void main(String args[]) {  
       Student stu1 = new Student();  
       stu1.setNumber(12345);  
       Student stu2 = stu1;  
         
       System.out.println("学生1:" + stu1.getNumber());  
       System.out.println("学生2:" + stu2.getNumber());  
   }  
}

结果：

学生1:12345  
学生2:12345

对象复制不过如此，真就这么简单？

改变stu2实例的number字段：

stu2.setNumber(54321);  
System.out.println("学生1:" + stu1.getNumber());  
System.out.println("学生2:" + stu2.getNumber());
学生1:54321  
学生2:54321

改变学生2的学号，学生1的学号怎么也发生变化呢？

原因出在(stu2 = stu1) 这一句。该语句的作用是将stu1的引用赋值给stu2，这样，stu1和stu2指向内存堆中同一个对象。

怎样才能正确复制一个对象？

Object有11个方法，两个protected方法，其中一个为clone：

Java对象的深克隆与浅克隆（对象复制）（上）

第一次声明保证克隆对象将有单独的内存地址分配。

第二次声明表明，原始和克隆的对象应该具有相同的类类型，但它不是强制性的。

第三声明表明，原始和克隆的对象应该是平等的equals()方法使用，但它不是强制性的。


因为每个类最终父类都是Object，因此它们都有clone()，但该方法是protected，所以都不能在类外进行访问。


要想对一个对象进行复制，就需重写clone()。

为什么克隆

直接new一个新的不行吗？

克隆的对象可能包含一些已经修改过的属性，而new出来的对象的属性都还是初始化时候的值，所以当需要一个新的对象来保存当前对象的“状态”就靠clone。


那我把这个对象的临时属性一个一个的赋值给我新new的对象不也行嘛。是可以，但是


麻烦

而clone是个native方法，快

常见的

Object a = new Object();
Object b;
b = a;

这种形式的代码复制的是引用，即对象在内存中的地址。

而通过clone方法赋值的对象跟原来的对象时同时独立存在。

如何实现克隆

浅、深克隆的主要区别在于是否支持引用类型的成员变量的复制。

浅克隆

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

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

对上面那个方法进行改造：

@Data
class Student implements Cloneable {
  
   private int 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());  
   }  
}

结果：

学生1:12345  
学生2:12345  
学生1:12345  
学生2:54321

如果不相信这两个对象不是同一个对象，那么你可以看看这一句：

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

深克隆

在学生类里再加一个Address类

@Data
class Address  {  
   private String add;  
}  

@Data 
class Student implements Cloneable {  
   private int number;  
 
   private Address addr;  
     
   @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());  
   }  
}

结果：

学生1:123,地址:杭州市  
学生2:123,地址:杭州市

在main方法中试着改变addr实例的地址。

addr.setAdd("西湖区");  
System.out.println("学生1:" + stu1.getNumber() + ",地址:" + stu1.getAddr().getAdd());  
System.out.println("学生2:" + stu2.getNumber() + ",地址:" + stu2.getAddr().getAdd());
结果：
学生1:123,地址:杭州市  
学生2:123,地址:杭州市  
学生1:123,地址:西湖区  
学生2:123,地址:西湖区

怎么两个学生的地址都改变了？

浅克隆只是复制了addr变量的引用，并没有真正的开辟另一块空间，将值复制后再将引用返回给新对象。

达到真复制对象，不是纯粹引用复制。要将Address类可复制化，且修改clone方法：

@Data
class Address implements Cloneable {  
   private String add;  

   @Override  
   public Object clone() {  
       Address addr = null;  
       try{  
           addr = (Address)super.clone();  
       }catch(CloneNotSupportedException e) {  
           e.printStackTrace();  
       }  
       return addr;  
   }  
}  
 
@Data
class Student implements Cloneable{  
   private int number;  
 
   private Address addr;  

   @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());  
   }  
}

结果：
学生1:123,地址:杭州市  
学生2:123,地址:杭州市  
学生1:123,地址:西湖区  
学生2:123,地址:杭州市

最后我们可以看看API里其中一个实现了clone方法的类：

Java对象的深克隆与浅克隆（对象复制）（上）

该类其实也属于深克隆。

上一篇：在C#中读取被其它进程打开的文件


下一篇：【无标题】