深拷贝和浅拷贝-CSDN博客

一、值传递和引用传递

在谈值传递和引用传递之前先了解下java数据类型有哪些

Java数据类型

java的数据类型有两大类，基本类型和对象类型。相应的，变量也有两种类型：基本类型和引用类型。

基本类型包括byte,short,int,long,char,float,double,boolean 这八大基本数据类型，

基本类型的变量保存原始值，即它代表的值就是数值本身，存放在栈内存中的数据段，因为是按值存储，可以直接访问和修改，原始值一般对应在内存上的栈区。

引用类型包括 类类型，接口类型和数组 保存的是引用值，引用值指向内存空间的地址。代表了某个对象的引用，而不是对象本身。对象本身存放在这个引用值所表示的地址的位置。被引用的对象对应内存上的堆内存去。

变量的基本类型和引用类型的区别

基本数据类型在声明是系统就给它分配空间，无论是否赋值，声明的时候虚拟机就会分配 4字节的内存区域。引用数据类型不同，它声明时只给变量分配了引用空间，而不分配数据空间。

String 类型时声明的时候没有分配数据空间，只有 4byte 的引用大小，在栈区，而在堆内存区域没有任何分配。

基本类型的变量是值传递；引用类型的变量

值传递

方法调用时，实际参数把它的值传递给对应的形式参数，函数接收的原始值得一个copy，此时内存中存在两个相等的基本类型，即实际参数和形式参数，后面方法中的操作都是对形参这个值得修改，不影响实际参数的值

引用传递

一般也称为地址传递。方法调用时，实际参数的引用（地址，而不是参数的值）被传递给方法中相对应的形式参数，函数接收的原始值的内存地址

在方法执行中，形参和实参内容相同，只想同一块内存地址，方法执行中对引用的操作将影响到实际对象。

二、什么是深拷贝和浅拷贝

浅拷贝和深拷贝都是对一个已有对象的操作，编译系统会自动调用一种构造函数——拷贝构造函数，如果用户未定义拷贝构造函数，则会调用默认拷贝构造函。

在java中，一般使用=好做赋值操作的时候，对于基本数据类型，实际上是拷贝他的值，但是对于对象而言，其实赋值的指示这个对象的引用，将原对象的引用传递过去，他们实际上还是指向的用一个对象。

而浅拷贝和深拷贝就是在这个基础之上做的区分，如果在拷贝这个对象的时候，只对基本数据类型进行了拷贝，而对引用数据类型只是进行了引用的传递，而没有创建一个新的对象，那就是浅拷贝。反之，在对引用数据类型进行拷贝的时候，新创建了一个新的对象，并完全复制了其内的成员变量，那么这就是深拷贝。

总结来说：

1、浅拷贝：对基本数据类型进行值传递，对引用数据类型进行引用传递般的拷贝，此为浅拷贝。

2、深拷贝：对基本数据类型进行值传递，对引用数据类型，创建一个新的对象，并复制其内容，此为深拷贝。

java中的clone方法

clone顾名思义就是复制，在java语言中，clone方法被对象调用，所以会复制对象，首先要分配一个和源对象同样大小的空间，在这个空间中创建一个新对象。

创建对象的方式

在java语言中，有几种方式可以创建对象呢？

1.使用new操作创建一个对象

2.使用clone方法复制一个对象

使用new操作创建对象本意是分配内存。程序只领到new操作符时，首先去看new操作符后面的类型，因为知道了类型，才能知道要分配多大的内存空间。分配完内存之后，再调用构造函数，填充对象的各个域，这就叫对象的初始化。对象穿件完毕后，可以把引用发布到外部，在外部就可以使用这个引用操纵这个对象。

clone在第一步和new相似的，都是分配内存的，调用clone方法时，分配的内存和源对象（即调用clone方法的对象）相同，然后在使用原对象中对应的各个域，填充新对象的域，填充完成之后，clone方法返回，一个新的相同对象就能被创建，同样吧这个新对象的引用发布到外部。

浅拷贝

先来看一个浅拷贝的例子

首先创建一个person类，是想Cloneable接口，并重写clone（）方法

package com.java.test;
public  class Person implements Cloneable {
    public String name;
    public int age;
    public Man man=new Man();
    public  Object clone(){
        try {
            return   super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return  null;
    }

    public static void main(String[] args){
        Person person=new Person();
        person.name="法法";
        person.age=24;
        Person cloneperson=(Person)person.clone();
        System.out.println("person==cloneperson  :"+(person==cloneperson));
        System.out.println("person hash  :"+person.hashCode());
        System.out.println("person hash  :"+cloneperson.hashCode());
        System.out.println("person.man==cloneperson.man  :"+(person.man ==cloneperson.man));
        System.out.println("person.man hash  :"+(person.man.hashCode()));
        System.out.println("cloneperson.man hash  :"+(cloneperson.man.hashCode()));
    }
}
class Man implements  Cloneable{
    public String name;
    public int age;
    public  Object clone(){
        try {
            return super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return null;
    }

}复制代码

输出
person==cloneperson  :false
person hash  :2039796785
person hash  :57283044
person.man==cloneperson.man  :true
person.man hash  :1971244528
cloneperson.man hash  :1971244528
复制代码

可以看出，使用clone方法，从==和hashCode不同可以看出，clone方法真的穿件了一个新的对象。

上面代码中可以看出两个Person对象的man的地址值相同，说明两个对象的man对象都指向同一个对象，也就是浅拷贝，。

而如果两个对象的man的地址值不同，那么就说明指向不同的对象，也就是在拷贝Person对象的时候，同时拷贝了man对象，也就是深拷贝。

深拷贝

既然已经了解了对 clone() 方法，只能对当前对象进行浅拷贝，引用类型依然是在传递引用。

那么，如何进行一个深拷贝呢？

比较常用的方案有两种：

序列化（serialization）这个对象，再反序列化回来，就可以得到这个新的对象，无非就是序列化的规则需要我们自己来写。
继续利用 clone() 方法，既然 clone() 方法，是我们来重写的，实际上我们可以对其内的引用类型的变量，再进行一次 clone()。

继续改写上面的 Demo ，让 ChildClass 也实现 Cloneable 接口。

package com.java.test;
public  class Person implements Cloneable {
    public String name;
    public int age;
    public Man man=new Man();
    public  Object clone(){
        try {
            Person p=(Person) super.clone();
            p.man=(Man)this.man.clone();
            return  p;
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return  null;
    }

    public static void main(String[] args){
        Person person=new Person();
        person.name="fafa";
        person.age=24;
        Person cloneperson=(Person)person.clone();
        System.out.println("person==cloneperson  :"+(person==cloneperson));
        System.out.println("person hash  :"+person.hashCode());
        System.out.println("person hash  :"+cloneperson.hashCode());
        System.out.println("person.man==cloneperson.man  :"+(person.man ==cloneperson.man));
        System.out.println("person.man hash  :"+(person.man.hashCode()));
        System.out.println("cloneperson.man hash  :"+(cloneperson.man.hashCode()));
    }
}
class Man implements  Cloneable{
    public String name;
    public int age;
    public  Object clone(){
        try {
            return super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return null;
    }

}复制代码

输出

person==cloneperson  :false
person hash  :1942571857
person hash  :611315258
person.man==cloneperson.man  :false
person.man hash  :813773958
cloneperson.man hash  :1923048010
复制代码

可以看到，对 man也进行了一次拷贝，这实则是对 Person进行的浅拷贝，但是对于 Person而言，则是一次深拷贝。