浅谈Java对象拷贝&浅拷贝&深拷贝

对象拷贝：对象拷贝没有生成新对象，对象地址是一样的

A类 public class A implements Cloneable{ private Integer a; private B b; public int getA() { return a; } public void setA(Integer a) { this.a = a; } @Override public String toString() { return "A{" + "a=" + a + ", b=" + b + '}'; } @Override protected Object clone() throws CloneNotSupportedException { return super.clone(); } public B getB() { return b; } public void setB(B b) { this.b = b; } } B类 public class B { private String b; public String getB() { return b; } public void setB(String b) { this.b = b; } @Override public String toString() { return "B{" + "b='" + b + '\'' + '}'; } } public static void main(String[] args) throws CloneNotSupportedException { // write your code here B b=new B(); b.setB("haha"); A a=new A(); a.setA(1); a.setB(b); System.out.println("对象拷贝前a的值 "+"a: "+a); A aa= a; aa.setA(2);//修改b而未修改a B bb=new B(); bb.setB("enen"); aa.setB(bb); System.out.println("对象拷贝后a的值 "+"a: "+a); }

结果为

对象拷贝前a的值 a: A{a=1, b=B{b='haha'}} 对象拷贝后a的值 a: A{a=2, b=B{b='enen'}}

我们发现对象拷贝并没有创建新的对象，而是引用a与aa都指向同一个地址 浅拷贝：简明的说，就是浅拷贝会创建一个新的对象，对于基本类型会拷贝值，而对于引用类型会拷贝地址，需要实现Cloneable接口并重写clone()方法

public static void main(String[] args) throws CloneNotSupportedException { // write your code here B b=new B(); b.setB("haha"); A a=new A(); a.setA(1); a.setB(b); System.out.println("浅拷贝拷贝前a的值 "+"a: "+a); A aa= (A) a.clone(); aa.setA(2);//修改b而未修改a B bb=aa.getB(); bb.setB("enen"); aa.setB(bb); System.out.println("浅拷贝拷贝后a的值 "+"a: "+a); }

结果为

浅拷贝拷贝前a的值 a: A{a=1, b=B{b='haha'}} 浅拷贝拷贝后a的值 a: A{a=1, b=B{b='enen'}}

我们发现浅拷贝确实是会创建一个新的对象，对于基本类型会拷贝值，对于引用类型则会拷贝地址，所以导致修改了aa的B，a的B也会跟着修改

深拷贝：浅拷贝会带来数据安全隐患，所以我们需要深拷贝，深拷贝需要对象里面的所有引用类型都要实现Cloneable接口并重写clone()方法

public class A implements Cloneable{ private Integer a; private B b; public int getA() { return a; } public void setA(Integer a) { this.a = a; } @Override public String toString() { return "A{" + "a=" + a + ", b=" + b + '}'; } @Override protected Object clone() throws CloneNotSupportedException { A a= (A) super.clone(); B bb= (B) b.clone(); a.setB(bb); return a; } public B getB() { return b; } public void setB(B b) { this.b = b; } } public class B implements Cloneable { private String b; public String getB() { return b; } public void setB(String b) { this.b = b; } @Override public String toString() { return "B{" + "b='" + b + '\'' + '}'; } @Override protected Object clone() throws CloneNotSupportedException { return super.clone(); } } public static void main(String[] args) throws CloneNotSupportedException { // write your code here B b=new B(); b.setB("haha"); A a=new A(); a.setA(1); a.setB(b); System.out.println("深拷贝拷贝前a的值 "+"a: "+a); A aa= (A) a.clone(); aa.setA(2);//修改b而未修改a B bb=aa.getB(); bb.setB("enen"); aa.setB(bb); System.out.println("深拷贝拷贝后a的值 "+"a: "+a); }

结果为

深拷贝拷贝前a的值 a: A{a=1, b=B{b='haha'}} 深拷贝拷贝后a的值 a: A{a=1, b=B{b='haha'}}

我们发现深拷贝后，aa的修改并未影响到a的值 Cloneable相关

/** * A class implements the <code>Cloneable</code> interface to * indicate to the {@link java.lang.Object#clone()} method that it * is legal for that method to make a * field-for-field copy of instances of that class. * <p> * Invoking Object's clone method on an instance that does not implement the * <code>Cloneable</code> interface results in the exception * <code>CloneNotSupportedException</code> being thrown. * <p> * By convention, classes that implement this interface should override * <tt>Object.clone</tt> (which is protected) with a public method. * See {@link java.lang.Object#clone()} for details on overriding this * method. * <p> * Note that this interface does <i>not</i> contain the <tt>clone</tt> method. * Therefore, it is not possible to clone an object merely by virtue of the * fact that it implements this interface. Even if the clone method is invoked * reflectively, there is no guarantee that it will succeed. * * @author unascribed * @see java.lang.CloneNotSupportedException * @see java.lang.Object#clone() * @since JDK1.0 */ public interface Cloneable { }

这个接口的说明我们去看文档

public interface Cloneable一个类实现Cloneable接口，以指示Object.clone()方法，该方法对于该类的实例进行现场复制是合法的。 在不实现Cloneable接口的实例上调用对象的克隆方法导致抛出异常CloneNotSupportedException 。 按照惯例，实现此接口的类应使用公共方法覆盖Object.clone （受保护）。 有关覆盖此方法的详细信息，请参阅Object.clone() 。 注意，此接口不包含clone方法。 因此，只能通过实现该接口的事实来克隆对象是不可能的。 即使克隆方法被反射地调用，也不能保证它成功。 从以下版本开始： JDK1.0 另请参见： CloneNotSupportedException ， Object.clone()

要想用Object.clone()方法就得实现Cloneable接口，否则会报CloneNotSupportedException 反例如下：

Exception in thread "main" java.lang.CloneNotSupportedException: com.company.wh.A at java.lang.Object.clone(Native Method) at com.company.wh.A.clone(A.java:24) at com.company.wh.Main.main(Main.java:11)

Object.clone()的文档里也很清楚的说明了这一点

protected Object clone() throws CloneNotSupportedException创建并返回此对象的副本。 “复制”的精确含义可能取决于对象的类。 一般的意图是，对于任何对象x ，表达式： x.clone() != x将是真实的，而且表达： x.clone().getClass() == x.getClass()将是true ，但这些都不是绝对的要求。 通常情况是： x.clone().equals(x)将是true ，这不是一个绝对的要求。 按照惯例，返回的对象应该通过调用super.clone获得。 如果一个类和它的所有超类（除了Object ）遵守这个惯例，那将是x.clone().getClass() == x.getClass()的情况。 按照惯例，此方法返回的对象应该与此对象（正被克隆）无关。 为了实现这一独立性，可能需要修改super.clone返回的对象的一个或多个字段。 通常，这意味着复制构成被克隆的对象的内部“深层结构”的任何可变对象，并通过引用该副本替换对这些对象的引用。 如果一个类仅包含原始字段或对不可变对象的引用，则通常情况下， super.clone返回的对象中的字段通常不需要修改。 clone的方法Object执行特定的克隆操作。 首先，如果此对象的类不实现接口Cloneable ，则抛出CloneNotSupportedException 。 请注意，所有数组都被认为是实现接口Cloneable ，并且数组类型T[]的clone方法的返回类型是T[] ，其中T是任何引用或原始类型。 否则，该方法将创建该对象的类的新实例，并将其所有字段初始化为完全符合该对象的相应字段的内容，就像通过赋值一样。 这些字段的内容本身不被克隆。 因此，该方法执行该对象的“浅拷贝”，而不是“深度拷贝”操作。 Object类本身并不实现接口Cloneable ，因此在类别为Object的对象上调用clone方法将导致运行时抛出异常。 结果 这个实例的一个克隆。 异常 CloneNotSupportedException - 如果对象的类不支持Cloneable接口。 覆盖clone方法的子类也可以抛出此异常以指示实例无法克隆。 另请参见： Cloneable

本来想看Object.clone()的源码，但发现是调用的本地方法

protected native Object clone() throws CloneNotSupportedException;

所以这个就结束了。。。

补充： 一直在思考，Integer，String等其实都是引用类型，也没见他们实现Cloneable接口，重写clone()方法，他们是怎么实现深浅拷贝的呢？ 看到一个最好的答案，就是String,Integer等是Immutable Object，每一次赋值，指向的都是堆上的一个新对象