深拷贝与浅拷贝的概念与区别

最新推荐文章于 2022-10-13 22:25:49 发布

$*¥*$*

最新推荐文章于 2022-10-13 22:25:49 发布

阅读量270

点赞数

本文链接：https://blog.csdn.net/weixin_43853718/article/details/103760864

版权

深拷贝与浅拷贝的概念与区别（以Java为例）
2019/12/10

深拷贝与浅拷贝

一、概念

关于Java的深拷贝和浅拷贝，简单来说就是创建一个和已知对象一模一样的对象。
1.深拷贝：也叫深克隆、深复制。
深拷贝不仅拷贝对象本身，而且拷贝对象包含的引用指向的所有对象。
2.浅拷贝：也叫浅克隆、浅复制。
浅拷贝是指拷贝对象时仅仅拷贝对象本身和对象中的基本变量，而不拷贝对象包含的引用指向的对象。

二、区别

首先引出一个概念：在 Java 中基本类型和引用类型的区别。
基本类型：也称为值类型，分别是字符类型 char，布尔类型 boolean以及数值类型 byte、short、int、long、float、double。
引用类型：包括类、接口、数组、枚举等。
Java 将内存空间分为堆和栈。基本类型直接在栈中存储数值，而引用类型是将引用放在栈中，实际存储的值是放在堆中，通过栈中的引用指向堆中存放的数据。
在这里插入图片描述
浅拷贝只是复制了引用，前后的对象指向的还是同一块内存区间；
浅拷贝：创建一个新对象，然后将当前对象的非静态字段复制到该新对象，如果字段是值类型的，那么对该字段执行复制；如果该字段是引用类型的话，则复制引用但不复制引用的对象。因此，原始对象及其副本引用同一个对象。在这里插入图片描述
深拷贝就是所有的属性都独立复制一份；
深拷贝：创建一个新对象，然后将当前对象的非静态字段复制到该新对象，无论该字段是值类型的还是引用类型，都复制独立的一份。当你修改其中一个对象的任何内容时，都不会影响另一个对象的内容。
在这里插入图片描述

三、实现方式

通过调用 Object 类的 clone() 方法来完成。在 Object.class 类中，源码为：
protected native Object clone() throws CloneNotSupportedException;
这是一个用 native 关键字修饰的方法，用 native 修饰的方法就是告诉操作系统，这个方法我不实现了，让操作系统去实现。

通过clone()方法来实现深拷贝、浅拷贝

1、重写clone()方法进行浅拷贝：

需要注意：
1、Object类虽然有这个方法，但是这个方法是受保护的（被protected修饰），所以我们无法直接使用。
2、使用clone方法的类必须实现Cloneable接口，否则会抛出异常CloneNotSupportedException。对于这两点，我们的解决方法是，在要使用clone方法的类中重写clone()方法，通过super.clone()调用Object类中的原clone方法。

参考代码

/* clone方法实现浅拷贝 */
public class ShallowCopy {
    public static void main(String[] args) {
        Age a=new Age(20);
        Student stu1=new Student("张三",a,175);
        
        //通过调用重写后的clone方法进行浅拷贝
        Student stu2=(Student)stu1.clone();
        System.out.println(stu1.toString());
        System.out.println(stu2.toString());
        
        //尝试修改stu1中的各属性，观察stu2的属性有没有变化
        stu1.setName("李四");
        //改变age这个引用类型的成员变量的值
        a.setAge(99);
        //stu1.setaAge(new Age(99));    使用这种方式修改age属性值的话，stu2是不会跟着改变的。因为创建了一个新的Age类对象而不是改变原对象的实例值
        stu1.setLength(216);
        System.out.println(stu1.toString());
        System.out.println(stu2.toString());
    }
}

/*
 * 创建年龄类
 */
class Age{
    //年龄类的成员变量（属性）
    private int age;
    //构造方法
    public Age(int age) {
        this.age=age;
    }
    
    public int getAge() {
        return age;
    }
    
    public void setAge(int age) {
        this.age = age;
    }
    
    public String toString() {
        return this.age+"";
    }
}
/*
 * 创建学生类
 */
class Student implements Cloneable{
    //学生类的成员变量（属性）,其中一个属性为类的对象
    private String name;
    private Age aage;
    private int length;
    //构造方法,其中一个参数为另一个类的对象
    public Student(String name,Age a,int length) {
        this.name=name;
        this.aage=a;
        this.length=length;
    }
    //eclipe中alt+shift+s自动添加所有的set和get方法
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    
    public Age getaAge() {
        return this.aage;
    }
    
    public void setaAge(Age age) {
        this.aage=age;
    }
    
    public int getLength() {
        return this.length;
    }
    
    public void setLength(int length) {
        this.length=length;
    }
    //设置输出的字符串形式
    public String toString() {
        return "姓名是： "+this.getName()+"， 年龄为： "+this.getaAge().toString()+", 长度是： "+this.getLength();
    }
    //重写Object类的clone方法
    public Object clone() {
        Object obj=null;
        //调用Object类的clone方法，返回一个Object实例
        try {
            obj= super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return obj;
    }
}

结果：
姓名是：张三，年龄为： 20, 长度是： 175
姓名是：张三，年龄为： 20, 长度是： 175
姓名是：李四，年龄为： 99, 长度是： 216
姓名是：张三，年龄为： 99, 长度是： 175

分析：
基本数据类型是值传递，所以修改值后不会影响另一个对象的该属性值；引用数据类型是地址传递（引用传递），所以修改值后另一个对象的该属性值会同步被修改。

2、重写clone方法来实现深拷贝

与通过重写clone方法实现浅拷贝的基本思路一样，只需要为对象图的每一层的每一个对象都实现Cloneable接口并重写clone方法，最后在最顶层的类的重写的clone方法中调用所有的clone方法即可实现深拷贝。简单的说就是：每一层的每个对象都进行浅拷贝=深拷贝。
参考代码

package linearList;
/* 层次调用clone方法实现深拷贝 */
public class DeepCopy {
    public static void main(String[] args) {
        Age a=new Age(20);
        Student stu1=new Student("张三",a,175);
        
        //通过调用重写后的clone方法进行浅拷贝
        Student stu2=(Student)stu1.clone();
        System.out.println(stu1.toString());
        System.out.println(stu2.toString());
        System.out.println();
        
        //尝试修改stu1中的各属性，观察stu2的属性有没有变化
        stu1.setName("李四");
        //改变age这个引用类型的成员变量的值
        a.setAge(99);
        //stu1.setaAge(new Age(99));    使用这种方式修改age属性值的话，stu2是不会跟着改变的。因为创建了一个新的Age类对象而不是改变原对象的实例值
        stu1.setLength(216);
        System.out.println(stu1.toString());
        System.out.println(stu2.toString());
    }
}

/*
 * 创建年龄类
 */
class Age implements Cloneable{
    //年龄类的成员变量（属性）
    private int age;
    //构造方法
    public Age(int age) {
        this.age=age;
    }
    
    public int getAge() {
        return age;
    }
    
    public void setAge(int age) {
        this.age = age;
    }
    
    public String toString() {
        return this.age+"";
    }
    
    //重写Object的clone方法
    public Object clone() {
        Object obj=null;
        try {
            obj=super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return obj;
    }
}
/*
 * 创建学生类
 */
class Student implements Cloneable{
    //学生类的成员变量（属性）,其中一个属性为类的对象
    private String name;
    private Age aage;
    private int length;
    //构造方法,其中一个参数为另一个类的对象
    public Student(String name,Age a,int length) {
        this.name=name;
        this.aage=a;
        this.length=length;
    }
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    
    public Age getaAge() {
        return this.aage;
    }
    
    public void setaAge(Age age) {
        this.aage=age;
    }
    
    public int getLength() {
        return this.length;
    }
    
    public void setLength(int length) {
        this.length=length;
    }
    public String toString() {
        return "姓名是： "+this.getName()+"， 年龄为： "+this.getaAge().toString()+", 长度是： "+this.getLength();
    }
    //重写Object类的clone方法
    public Object clone() {
        Object obj=null;
        //调用Object类的clone方法——浅拷贝
        try {
            obj= super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        //调用Age类的clone方法进行深拷贝
        //先将obj转化为学生类实例
        Student stu=(Student)obj;
        //学生类实例的Age对象属性，调用其clone方法进行拷贝
        stu.aage=(Age)stu.getaAge().clone();
        return obj;
    }
}

结果：
姓名是：张三，年龄为： 20, 长度是： 175
姓名是：张三，年龄为： 20, 长度是： 175
姓名是：李四，年龄为： 99, 长度是： 216
姓名是：张三，年龄为： 20, 长度是： 175

分析：
进行了深拷贝之后，无论是什么类型的属性值的修改，都不会影响另一个对象的属性值。

[1]https://www.cnblogs.com/mikeCao/p/8710837.html
[2]https://www.cnblogs.com/shakinghead/p/7651502.html
[3]https://www.cnblogs.com/ysocean/p/8482979.html#_label0

$*¥*$*

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
深拷贝与浅拷贝的概念与区别

深拷贝与浅拷贝的概念与区别（以Java为例）2019/12/10深拷贝与浅拷贝一、概念关于Java的深拷贝和浅拷贝，简单来说就是创建一个和已知对象一模一样的对象。1.深拷贝：也叫深克隆、深复制。深拷贝不仅拷贝对象本身，而且拷贝对象包含的引用指向的所有对象。2.浅拷贝：也叫浅克隆、浅复制。浅拷贝是指拷贝对象时仅仅拷贝对象本身和对象中的基本变量，而不拷贝对象包含的引用指向的对象。二、...
复制链接

扫一扫