浅拷贝-深拷贝总结

最新推荐文章于 2022-02-18 14:35:24 发布
最新推荐文章于 2022-02-18 14:35:24 发布
阅读量77 收藏
点赞数
分类专栏： java 文章标签： 接口 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a1290320893/article/details/117420037
版权
本文总结了浅拷贝和深拷贝的区别，包括基本数据类型和引用数据类型的处理方式，浅拷贝主要通过拷贝构造函数和重写clone()方法，而深拷贝则涉及对象序列化。通过实例展示了如何在Java中分别实现这两种复制策略，并强调了深拷贝的复杂性和序列化作为替代方法的应用。
摘要由CSDN通过智能技术生成

浅拷贝-深拷贝总结

浅拷贝：

基本数据类型引用数据类型
值传递成员变量的引用值（内存地址）复制（实际指向同一个）

深拷贝：

基本数据类型引用数据类型
值传递new一个新对象，进行属性赋值

浅拷贝两种实现方法

1、拷贝构造函数
一个学生类，包含两个属性，一个是基本数据类型name，一个是引用数据类型Age

public class Boy {
    String name;
    Age age;

    public Boy() {
    }

    public Boy(String name, Age age) {
        this.name = name;
        this.age = age;
    }
    //拷贝构造函数，实现了对象的拷贝，基本数据类型值传递，引用数据类型内存地址复制
    public Boy(Boy b){
        this.age = b.age;
        this.name = b.name;
    }

    public Age getAge() {
        return age;
    }

    public void setAge(Age age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Boy{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

class Age{
    int age;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Age(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Age{" +
                "age=" + age +
                '}';
    }
}

public class Copyconstructor {
    public static void main(String[] args) {
        Age age = new Age(26);
        Boy boy = new Boy("pmh",age);
        //通过拷贝构造函数实现了对象的浅拷贝
        Boy boy1 = new Boy(boy);
        //我们通过修改其中一个去判断
        boy.name = "zyf";
        age.setAge(99);
        System.out.println(boy);
        System.out.println(boy1);
    }
}

结果

Boy{name='zyf', age=Age{age=99}}
Boy{name='pmh', age=Age{age=99}}

2、重写clone()方法进行浅拷贝
注意点：
1、protected native Object clone() throws CloneNotSupportedException;权限是受保护的，我们无法直接使用
2、使用clone方法的类必须实现Cloneable接口，否则会抛出异常CloneNotSupportedException
在这里插入图片描述

步骤如下

1、对象如果想通过clone方法实现浅拷贝，首先需要实现cloneable接口，重写clone()方法

public class Student implements Cloneable {
    String name;
    Score score;

    public Student(String name, Score score) {
        this.name = name;
        this.score = score;
    }

    public Student() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Score getScore() {
        return score;
    }

    public void setScore(Score score) {
        this.score = score;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", score=" + score +
                '}';
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}


class Score{
    int score;

    public Score(int score) {
        this.score = score;
    }

    public int getScore() {
        return score;
    }

    public void setScore(int score) {
        this.score = score;
    }

    @Override
    public String toString() {
        return "Score{" +
                "score=" + score +
                '}';
    }
}

public class CopyCloneable {
    public static void main(String[] args) {
        Score score = new Score(100);
        Student student = new Student("pmh",score);
        try {
            //由此我们通过实现了Cloneabe的实现类Student重写的clone方法实现了浅拷贝
            Student student1 = (Student)student.clone();
            System.out.println(student);
            System.out.println(student1);
            student.name = "ZYhf";
            score.score = 99;
            System.out.println(student);
            System.out.println(student1);
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}

结果

Student{name='pmh', score=Score{score=100}}
Student{name='pmh', score=Score{score=100}}
Student{name='ZYhf', score=Score{score=99}}
Student{name='pmh', score=Score{score=99}}

深拷贝两种实现方法

1、重写clone方法来实现深拷贝
1、假设Student有两个属性，一个基本数据类型name，一个引用数据类型Socre，我们首先需要让Score实现cloneable接口，重写方法clone()

class Score implements Cloneable{
    int score;

    public Score(int score) {
        this.score = score;
    }

    public int getScore() {
        return score;
    }

    public void setScore(int score) {
        this.score = score;
    }

    @Override
    public String toString() {
        return "Score{" +
                "score=" + score +
                '}';
    }

    @Override
    protected Object clone()  {
        Object obj = null;
        try {
            obj =  super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return obj;
    }
}

2、然后让Student实现cloneable接口，实现clone方法，通过获取拷贝的Student实例的Score属性重新进行一次拷贝

public class Student implements Cloneable {
    String name;
    Score score;

    public Student(String name, Score score) {
        this.name = name;
        this.score = score;
    }

    public Student() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Score getScore() {
        return score;
    }

    public void setScore(Score score) {
        this.score = score;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", score=" + score +
                '}';
    }
    @Override
    protected Object clone()  {
        Object obj = null;
        try {
            obj = super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
            Student stu = (Student) obj;
         stu.score= (Score) stu.getScore().clone();
        return obj;
    }
}

结果

Student{name='pmh', score=Score{score=100}}
Student{name='pmh', score=Score{score=100}}
Student{name='ZYhf', score=Score{score=99}}
Student{name='pmh', score=Score{score=100}}

虽然层次调用clone方法可以实现深拷贝，但是显然代码量实在太大。特别对于属性数量比较多、层次比较深的类而言，每个类都要重写clone方法太过繁琐。
2、通过对象序列化实现深拷贝

class Hobby implements Serializable{
    private String hobby;

    public String getHobby() {
        return hobby;
    }

    public void setHobby(String hobby) {
        this.hobby = hobby;
    }

    public Hobby(String hobby) {
        this.hobby = hobby;
    }

    @Override
    public String toString() {
        return "Hobby{" +
                "hobby='" + hobby + '\'' +
                '}';
    }
}

public class Girl implements Serializable{
    private String name;
    private Hobby hobby;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Hobby getHobby() {
        return hobby;
    }

    public void setHobby(Hobby hobby) {
        this.hobby = hobby;
    }

    public Girl(String name, Hobby hobby) {
        this.name = name;
        this.hobby = hobby;
    }

    @Override
    public String toString() {
        return "Girl{" +
                "name='" + name + '\'' +
                ", hobby=" + hobby +
                '}';
    }
}

public class CopyWithSerializable {
    public static void main(String[] args) throws Exception {
        Hobby hobby = new Hobby("乒乓球");
        Girl girl1 = new Girl("pmh",hobby);
        //通过序列化方法实现深拷贝
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(girl1);
        oos.flush();
        ObjectInputStream ois=new ObjectInputStream(new ByteArrayInputStream(bos.toByteArray()));
        Girl girl2=(Girl)ois.readObject();
        System.out.println(girl1.toString());
        System.out.println(girl2.toString());
        System.out.println();
        //尝试修改stu1中的各属性，观察stu2的属性有没有变化
        girl1.setName("大傻子");
        //改变age这个引用类型的成员变量的值
        hobby.setHobby("羽毛器");
        girl1.setName("216");
        System.out.println(girl1.toString());
        System.out.println(girl2.toString());
    }
}

结果

Girl{name='pmh', hobby=Hobby{hobby='乒乓球'}}
Girl{name='pmh', hobby=Hobby{hobby='乒乓球'}}
Girl{name='216', hobby=Hobby{hobby='羽毛器'}}
Girl{name='pmh', hobby=Hobby{hobby='乒乓球'}}
java请多指教
关注
专栏目录
深浅拷贝——Java
Sophiahaha的博客
08-08 178
一、深浅拷贝（对象） protected native Object clone() throws CloneNotSupportedException; 要想让对象具有拷贝的功能，必须要实现Cloneable接口（标识接口，表示此类允许被克隆），并且在类中自定义clone调用Object类提供的继承权限clone方法。 （只有接口名称，没有任何抽象方法，标识接口，给所有实现这个接口的类打上...
java.lang.Object.clone()的分析
最新发布
weixin_45746505的博客
01-18 1036
java.lang.Object.clone的分析
protected访问权限解释——以Object的clone()方法为例
mrhanzhou5273的博客
02-20 2126
protected访问权限解释 Object的clone()方法简要介绍 Object类中的clone方法声明为protected，源码如下： protected native Object clone() throws CloneNotSupportedException; java中的native关键字表示这个方法是个本地方法。而且native修饰的方法执行效率比非native修饰的高。   protected访问权限解释 protected访问权限允许字段或方法被同一个包下的类访问。此外，对于子
Object类clone方法深度解析
qq_39241239的博客
10-28 931
首先我们来看下clone方法的源码 protected native Object clone() throws CloneNotSupportedException; 通过源代码可以发现几点： clone方法是native方法，native方法的效率远高于非native方法，因此还是使用clone方法去做对象的拷贝而不是使用new的方法，copy。 此方法被protected修饰。这...
java deepcloneobject,Java Object之clone()方法
weixin_42348371的博客
03-19 154
Object中的clone方法定义如下：protected native Object clone() throws CloneNotSupportedException;定义一个可克隆的对象，一般的步骤如下：implements Cloneable;override clone()Example//Person及其子类都有了克隆能力class Person implements Cloneabl...
java深入理解浅拷贝和深拷贝
12-21
总结起来，Java中的浅拷贝和深拷贝是处理对象复制时必须了解的关键概念。浅拷贝速度快，但可能导致对象间的相互影响；深拷贝虽然消耗更多资源，但能保证对象的独立性。在开发过程中，应根据实际需求选择合适的拷贝...
js中的深拷贝和浅拷贝总结
01-08
1、浅拷贝 2、深拷贝 二、实现方式 1、浅拷贝的实现方式 1.1 Object.assign(target,source)方法 1.2 Array.prototype.concat()方法 1.3 Array.prototype.slice(start,end)方法 2、深拷贝的实现方式 2.1 JSON.parse...
Java Clone深拷贝与浅拷贝的两种实现方法
08-26
Java Clone 深拷贝与浅拷贝的两种实现方法 Java Clone 是 Java 语言中的一种复制对象的机制，它可以将一个对象的所有属性和状态复制到另一个对象中，实现对象的深拷贝和浅拷贝。下面我们将讨论 Java 中的深拷贝和浅...
对浅拷贝、深拷贝、写时拷贝的简单认识
01-20
总结起来，浅拷贝、深拷贝和写时拷贝都是在处理对象拷贝时考虑的重点。理解它们的差异和适用场景是编写高效、安全的代码的关键。在实现涉及资源管理的类时，应确保正确处理拷贝构造函数、赋值运算符重载以及析构函数...
图解：python中的浅拷贝和深拷贝
12-21
总结来说，浅拷贝只复制一层对象，而深拷贝会递归复制所有层次的对象，确保新对象与原对象完全独立。在处理包含复杂数据结构的程序时，理解这两种拷贝的区别对于避免意外的数据修改和保持数据一致性至关重要。在需要...
【Java基础知识 21】java object类
学Java，找哪吒
11-20 6234
Java基础教程系列（入门篇），打造精品专栏。
关于Object类的clone()方法
can_chen的博客
06-17 1683
clone()方法是用于浅克隆或者深克隆一个java对象的，但是要注意一个误区：clone方法是Object类的，并不是Cloneable接口的，Cloneable只是一个标记接口，标记接口是用于标记实现该接口的类具有某种该接口标记的功能，常见的标记接口有三个：Serializable、Cloneable、RandomAccess，没有实现Cloneable接口，那么调用clone方法就会爆出CloneNotSupportedException异常。 要使得一个java类可以实现克隆，那么该类就需要实现Cl
Java:由Object.clone()而引出的protected权限问题
BAOLIANG196的博客
11-12 7710
Object.clone()大家可能不太理解由Object.clone()而引出的protected权限问题这句话，那我们先看一段代码： 第一个类CloneClassOne package com.ustc.sup; public class CloneClassOne { }第二个类CloneClassTwo package com.ustc.sup;public class CloneClas
[Java]由Object.clone()方法引出的访问权限问题
qq_41409138的博客
02-04 8425
[Java]由Object.clone()方法引出的访问权限问题 在学习Java的过程中，在《Java核心技术》（卷一）中看到这样一句话“因为Object类中的clone()方法是protected，所以不能直接以anObject.clone()这样的形式调用。当时看到的时候有些不解，之前学习的时候，对protected的认识是这样的 protected 修饰的类和属性,对于自己、本包和其子类可...
Object.clone()方法
架构师专栏
03-30 6893
      Object.clone()方法用于对象的拷贝，它会把在堆上的对象所占用的内存空间拷贝一份然后返回，这样就形成一个新的对象（个人理解）。因为每个对象所占的空间内都有一个指向其类数据的指针，也就是指向方法区中类数据（这个类数据可以通过Class对象进行访问，可以简单、直接的理解为就是指向代表其类的Class对象）。JVM会通过这个指针来判断一个对象的类型，由于把整个对象空间拷贝，所以拷贝的对象的类指针也指向相同的类对象，这就确保了obj.clone().getClass()==obj.getCla
Java-Object类源码解析
benjaminlee1的博客
06-02 6728
一，Object类简述Object类是Java中所有类的基类，在编译时会自动导入，位于java.lang包中，而Object中具有的属性和行为，是Java语言设计背后的思维体现。这里写的代码是JDK8中的，其他版本的JDK可能略有不同。 包含的方法如下图： Object类方法说明Object类中的大部分方法都是native方法，用此关键字修饰的方法是Java中的本地方法，一般是用C/C++语言来
java Object类 clone()方法 详解
three__stones的博客
03-22 5910
今天写程序的时候像直接调用Object的clone()方法来copy一个副本，但是发现myEclipse的提示中并没有该方法，以为在jdk1.7中取消了该方法，然后我直接敲上clone()后： public class TestObject { public static void main(String[] args) { Student s = new Student(1, "小时")
JAVA中对象的克隆
weixin_47698996的博客
02-18 2999
对象克隆 Object类中定义一个clone方法 protected native Object clone() throws CloneNotSupportedException; native方法用于声明一个非java语言实现的代码，供java程序调用。因为java语言程序是运行在JVM上， 如果要访问比较底层的与操作系统相关的方法就没有办法了，只能通过比较靠近系统的语言来实现，比 如C/C++。 Object a=new Object(); Object b=a; //变量b中存储的是变量a的引用
Java中Object类之clone()方法详解
热门推荐
学习记录
10-16 1万+
一、clone()方法 clone意思是克隆、复制。在Java语言中，当对象调用clone()方法时，就会复制已有的对象。clone()方法在根类Object中定义如下。 /** * Class Object is the root of the class hierarchy. Every class has Object as a superclass. * Al...
Python浅拷贝与深拷贝详解
"Python的核心编程中，浅拷贝和深拷贝是两个重要的概念，涉及到对象复制的机制。本文将深入探讨这两个概念。 一、浅拷贝 浅拷贝（Shallow Copy）是Python中默认的拷贝方式。当你通过赋值操作`b = a`创建一个新对象`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值