[JAVA][浅拷贝和深拷贝]

1.落笔缘由

突然看到以前的笔记，思绪回到了上学的时候，满满的都是回忆，以前的不堪与幼稚的想法现在想起来都会忍不住笑出声了。现在打算整理以前的东西，算是朝花夕拾吧。

2.浅拷贝和深拷贝概念

1）浅复制（浅克隆） ：

网上有很多说法，但是我认为浅复制就是只复制被复制对象的引用（这里的对象指的不上JAVA里的一种数据类型，而是一种泛指，这个对象可以是JAVA里的基本类型，String类型或通过new创建的对象等），而不复制被复制对象的内容。最明显的现象就是如果改变复制对象的值，被复制的对象的值也会改变。

2）深复制（深克隆） ：

而深拷贝则是复制被复制对象的内容，最明显的现象就是如果改变复制对象的值，被复制的对象的值不会改变，也就是说复制对象和被复制对象是两个独立的个体，不会因为一个发生了改变而引起另一个发生改变。

3.JAVA中用”=”来赋值，对于基本类型，String类型和对象来说是深拷贝还是浅拷贝?

1)"="对基本类型来说是深拷贝

这里我就以整型来做例子

public class TestNum {

    public static void main(String[] args) {
        int int1 = 111;
        int int2 = int1;
        System.out.println("int1:"+int1);
        System.out.println("int2:"+int2);
        int2 = 222;
        System.out.println("After:");
        System.out.println("int1:"+int1);
        System.out.println("int2:"+int2);
    }
}
//输出结果：
//int1:111
//int2:111
//After:
//int1:111
//int2:222

我们可以看到改变了int2之后，int1并不会跟着改变，这是因为基本类型存放在内存的栈区里，当将111赋值给int1的时候，会在栈区存放111，int1指向111，当将int2=int1的时候，int2也是指向存放111的内存地址，而不会在栈区再另外开一个地址来存放111，也就是说栈区只会存放一个111整型。当int2=222的时候，这时候会在栈区新建一个地址用来存放222这个数值，这时候int2指向这个存放222的内存地址。

2）"="对String类型来说是深拷贝

public class TestString {

    public static void main(String[] args) {
        String str1 = "lgy";
        String str2 = str1;
        System.out.println("str1:"+str1);
        System.out.println("str2:"+str2);
        str2 = "lss";
        System.out.println("After:");
        System.out.println("str1:"+str1);
        System.out.println("str2:"+str2);
    }
}
//输出结果：
//str1:lgy
//str2:lgy
//After:
//str1:lgy
//str2:lss

其实String有点像基本类型，只不过它是存放在常量池里（String被final修饰）。

3）"="对对象来说是浅拷贝

/**
 * @author LGY
 * 对对象用=号来赋值是一种浅拷贝
 */
public class TestObject {

    public static void main(String[] args) {
        Child child1 = new Child();
        child1.setAge(5);
        child1.setName("jerry");
        Child child2 = child1;
        System.out.println("child1---name:"+child1.getName()+" age:"+child1.getAge());
        System.out.println("child2---name:"+child2.getName()+" age:"+child2.getAge());
        System.out.println("After:");
        child2.setAge(7);
        child2.setName("Tom");
        System.out.println("child1---name:"+child1.getName()+" age:"+child1.getAge());
        System.out.println("child2---name:"+child2.getName()+" age:"+child2.getAge());
    }
}
//输出结果：
//child1---name:jerry age:5
//child2---name:jerry age:5
//After:
//child1---name:Tom age:7
//child2---name:Tom age:7

用等于号来对对象拷贝，child1 和child2引用指向的是堆里的同一个对象，可以看到改变child2的信息，child1的信息也跟着改变了，这就是浅拷贝的效果。

4.对对象类型进行深拷贝

在网上也看了，对对象进行很拷贝好像有好几种方法，没仔细看。这里只介绍Cloneable这个方法。其实只需要实现Cloneable接口，重写里面的clone方法即可,先了解一下这个例子要表达的意思，我要将克隆一个Child,以ChildDeepCopy 1为模版，生成一个新的Child，也就是ChildDeepCopy 2，ChildDeepCopy 1和ChildDeepCopy 2互不影响。
首先，我们让这个ChildDeepCopy 实现Cloneable接口，重写clone方法，如下：

public class ChildDeepCopy implements Cloneable{

    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    
    public Object clone() {
        Object o=null;  
        try{  
            o= super.clone();  
        }catch(CloneNotSupportedException e){  
            System.out.println(e.toString());  
        }
        return o; 
    }
}

然后我们只要调用clone方法既可克隆出一个新的个体：

public class TestObjectDeepCopy {
    public static void main(String[] args) {
        ChildDeepCopy child1 = new ChildDeepCopy();
        child1.setAge(5);
        child1.setName("jerry");
        ChildDeepCopy child2 = (ChildDeepCopy) child1.clone();
        System.out.println("child1---name:"+child1.getName()+" age:"+child1.getAge());
        System.out.println("child2---name:"+child2.getName()+" age:"+child2.getAge());
        System.out.println("After:");
        child2.setAge(7);
        child2.setName("Tom");
        System.out.println("child1---name:"+child1.getName()+" age:"+child1.getAge());
        System.out.println("child2---name:"+child2.getName()+" age:"+child2.getAge());
    }
}

5.总结