对象克隆

最新推荐文章于 2024-11-04 23:24:03 发布
最新推荐文章于 2024-11-04 23:24:03 发布
阅读量111 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36321750/article/details/110845417
版权

当拷贝一个变量时，原始变量与拷贝变量引用同一个对象，改变一个变量将对另一个对象产生影响。

Employee original = new Employee("Morty", 400000);
Employee copy = original;
copy.raiseSalary(10);//oops--also changed original

​ 而clone()希望达到的目的是，在改变一个变量时对另一个变量没有影响。比如：

Employee original = new Employee("Morty", 400000);
Employee clone = (Employee) original.clone();
clone.raiseSalary(10);//original Not Changed

​ 在一般情况下，调用Cloneable接口总没有错，比如下例在基本数据类型上clone()的应用，int、String这样的变量在克隆之后可以随意更改。但是注意，代码20行是Cloneable接口默认方法，在没有重写时默认为return (Object) super.clone();，这样的clone称之为浅克隆。

public class CloneTest1 {
    public static void main(String[] args) {
        try {
            Student morty = new Student(22, "Morty");
            Student daisy = morty.clone();
            daisy.setName("Daisy");
            daisy.setAge(21);
            System.out.println(morty);//Student{age=22, name='Morty'}
            System.out.println(daisy);//Student{age=21, name='Daisy'}
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }

    public static class Student implements Cloneable {
        private int age;
        private String name;

        public Student clone() throws CloneNotSupportedException {
            return (Student) super.clone();
        }

        public Student(int age, String name) {
            this.age = age;
            this.name = name;
        }

        public int getAge() {
            return age;
        }

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

        public String getName() {
            return name;
        }

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

        @Override
        public String toString() {
            final StringBuffer sb = new StringBuffer("Student{");
            sb.append("age=").append(age);
            sb.append(", name='").append(name).append('\'');
            sb.append('}');
            return sb.toString();
        }
    }
}

​ 然而，一般的对象除了基本数据类型，都包含有自身独有的类，比如Teacher有自己的name，也有自己的Student。那么，克隆Teacher之后，新Teacher的Student类变量改变时，原来Teacher的Student类变量也像name变量一样不会变吗？在下面的代码中，teacher2首先克隆了teacher1的name和Student，之后更改了name，显然不会改变teacher1的name。更改Student类变量的name和age后，teacher1的Student类的name和age也改变了！说明clone操作很懒，它并没有为teacher2新建一个Student类变量，而是让它指向与teacher1同一个目标，或者说引用。

public class CloneTest2 {
    public static void main(String[] args) {
        try {
            CloneTest1.Student student1 = new CloneTest1.Student(22, "morty");
            Teacher teacher1 = new Teacher();
            teacher1.setName("Dr.Rick");
            teacher1.setAge(45);
            teacher1.setStudent(student1);

            Teacher teacher2 = (Teacher) teacher1.clone();
            CloneTest1.Student student2 = teacher2.getStudent();

            teacher2.setName("Dr.Ham");
            teacher2.setAge(46);
            student2.setAge(23);
            student2.setName("daisy");

            System.out.println(teacher1);//Teacher{name='Dr.Rick', age=45, student=Student{age=23, name='daisy'}}
            System.out.println(teacher2);//Teacher{name='Dr.Ham', age=46, student=Student{age=23, name='daisy'}}
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }

    }

    static class Teacher implements Cloneable {
        private String name;
        private int age;
        private CloneTest1.Student student;

        public int getAge() {
            return age;
        }

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

        public String getName() {
            return name;
        }

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

        public CloneTest1.Student getStudent() {
            return student;
        }

        public void setStudent(CloneTest1.Student student) {
            this.student = student;
        }

        @Override
        public String toString() {
            final StringBuffer sb = new StringBuffer("Teacher{");
            sb.append("name='").append(name).append('\'');
            sb.append(", age=").append(age);
            sb.append(", student=").append(student);
            sb.append('}');
            return sb.toString();
        }

        @Override
        protected Object clone() throws CloneNotSupportedException {
            return super.clone();//依旧是浅克隆
        }
    }
}

问题出在return (Object) super.clone();这行代码上，浅克隆并不会克隆除了基础数据类型之外的类。要想实现其他复杂类的克隆，避免编译器将复杂类简单地通过引用来处理，而非创立一个新的类，就需要重写clone()类。代码如下，注意第29~31行的写法。这样重写以后，改变teacher2的Student类就不会对teacher1产生影响。这样重写clone()类的clone称为深克隆。

public class CloneTest3 {
    public static void main(String[] args) {
        try {
            CloneTest1.Student student1 = new CloneTest1.Student(22,"morty");
            Teacher teacher1 = new Teacher();
            teacher1.setStudent(student1);
            teacher1.setName("Dr.Rick");

            Teacher teacher2 = (Teacher) teacher1.clone();
            teacher2.setName("Dr.Ham");
            CloneTest1.Student student2 = (CloneTest1.Student) teacher2.getStudent();
            student2.setName("daisy");
            student2.setAge(22);

            System.out.println(teacher1);//Teacher{name='Dr.Rick', student=Student{age=22, name='morty'}}
            System.out.println(teacher2);//Teacher{name='Dr.Ham', student=Student{age=22, name='daisy'}}
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    static class Teacher implements Cloneable {
        private String name;
        private CloneTest1.Student student;

        @Override
        protected Object clone() throws CloneNotSupportedException {
                Teacher teacher = (Teacher) super.clone();
            teacher.setStudent((CloneTest1.Student) teacher.getStudent().clone());
            return teacher;
        }

        public String getName() {
            return name;
        }

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

        public CloneTest1.Student getStudent() {
            return student;
        }

        public void setStudent(CloneTest1.Student student) {
            this.student = student;
        }

        @Override
        public String toString() {
            final StringBuffer sb = new StringBuffer("Teacher{");
            sb.append("name='").append(name).append('\'');
            sb.append(", student=").append(student);
            sb.append('}');
            return sb.toString();
        }
    }

}

总结

浅克隆只克隆基本数据类型的变量，对于非基本类型数据仅仅让clone对象引用原来的数据，改变非基本数据类型，原来的数据也会改变。

@Override
protected Object clone() throws CloneNotSupportedException {
    return super.clone();//浅克隆
}

深克隆可以克隆所有数据类型的变量，只要在clone()方法里对特别的类进行重写。

@Override
protected Object clone() throws CloneNotSupportedException {
    Teacher teacher = (Teacher) super.clone();
    teacher.setStudent((CloneTest1.Student) teacher.getStudent().clone());
    return teacher;//深克隆
}

把本文代码自己敲一遍就懂了浅拷贝和深拷贝。在实际应用中，由于这种clone操作太复杂，不适合大量引用的场景，一般都采用json格式记录各种数据。

Mortttty
关注
36. JAVA高级技术-对象克隆5（几种深克隆效率比较）
CSDN全栈领域优秀博主，阿里云博客专家，工信部权威认证物联网技术开发工程师，曾30分钟高分通过C语言二级，两天手撸代码完成EasyX飞机大战，靠接软件私活一个月换苹果电脑
04-27 524
JAVA高级技术-对象克隆5（几种深克隆效率比较）
java stream api 对象复制_java 复制对象 (克隆接口 与 序列化)
weixin_35589827的博客
02-16 1416
关于java对象复制我们在编码过程经常会碰到将一个对象传递给另一个对象，java中对于基本型变量采用的是值传递，而对于对象比如bean传递时采用的是应用传递也就是地址传递，而很多时候对于对象传递我们也希望能够象值传递一样，使得传递之前和之后有不同的内存地址，在这种情况下我们一般采用以下两种情况。1 对象克隆什么是"clone"？在实际编程过程中，我们常常要遇到这种情况：有一个对象A，在某一时刻A中...
java对象复制_java如何实现对象克隆
weixin_39613385的博客
02-12 110
上述方法抛出了一个CloneNotSupportedException异常，如果要实现对象克隆的类没有实现Cloneable接口，则会抛出此异常。但是Cloneable接口没有任何方法，这个是一个标识接口，标识一种操作能力。package com.gwolf.bean;public class Department implements Cloneable{private Integer dep...
android 对象克隆,android 浅复制和深复制-clone篇
weixin_33895274的博客
05-26 1683
有关java中的浅复制和深复制，这里不详细讨论。相关知识请参考以下帖子：浅复制和深复制http://blog..net/yang_hui1986527/article/details/7029777浅析Java中的深拷贝与浅拷贝http://blog..net/yang_hui1986527/article/details/7012428android中的浅复制和深复制，具体可能于java中的...
C# 对象复制 拷贝
热门推荐
XiaoFeng开源类库
06-13 2万+
在我们工作中经常会用到对象复制的情况，比如 A对象为原有对象，把A对象赋值给B对象，记录原有数据，然后对A对象开始操作改变值，接着想知道 A都改变了那些值 都会先这样写： A a = new A(); a.ID = 10; a.Name = "jacky"; A b = a; a.ID = 11; a.Name = "zhuovi"; 然后 结果并不是我们想要的，a b 两对象的值都...
java克隆一个流对象_Java基础 - 对象克隆（复制）
weixin_33278819的博客
02-28 760
假如说你想复制一个简单变量。很简单：int apples = 5;int pears = apples;不仅仅是int类型，其它七种原始数据类型(boolean,char,byte,short,float,double.long)同样适用于该类情况。但是如果你复制的是一个对象，情况就有些复杂了。假设说我是一个beginner，我会这样写：classStudent {private intnumbe...
Java对象克隆(复制)
weixin_43691098的博客
08-26 864
1.为什么要克隆？ 假如说你想复制一个简单变量。很简单： int apples = 5; int pears = apples; 不仅仅是int类型，其它七种原始数据类型(boolean,char,byte,short,float,double.long)同样适用于该类情况。但是如果你复制的是一个对象，情况就有些复杂了。 假设说我是一个beginner，我会这样写： public class Student { private String name; public Studen
对象克隆知识点
weixin_45866849的博客
08-06 417
对象克隆知识点 1.对象克隆 ​ 将原有的一个包含数据的对象，克隆出一个新的对象，新对象包含原来对象数据。 2为什么需要克隆？ ​ 克隆的对象可能包含一些已经修改过的属性，而new出来的对象的属性都还是初始化时候的值，所以当需要一个新的对象来保存当前对象的“状态”就靠clone方法了。 ​ 通过源码可以看到Object中的clone方法是一个native方法。特点：快速，在底层实现的。 误区： Student stu1 = new Student (); Student stu2 = stu1 ; 这种形
Delphi对象克隆技术
zisongjia的博客
04-26 3226
Delphi交流QQ:2609715119关键字: 原型模式,对象克隆,Prototype,Clone概述：在这篇文件中，讲述原型模式定义、结构、应用、实现。深入讨论了Delphi中原型模式的实现方法。特别研究了原型模式的核心技术——对象克隆技术在Delphi中的实现途径。本文还探讨了对象引用复制和对象克隆的区别，以及VCL的持久对象机制、对象流化技术。1、原型模式解说原型模式通过给出一个原型对象...
Java - 对象克隆
xx12321q的博客
05-23 984
目录 对象克隆 浅克隆 深克隆 多层克隆 对象克隆 在讨论对象克隆之前, 可能会有人说 , 不能直接new一个吗?为什么要克隆 首先关于这个问题, 直接new一个对象, 这个对象里面包含的成员变量是null的 , 那问题又来了, 我不能去一个个set对象的值吗? 当然可以, 但这样麻烦, 对象克隆采用的是native方法,效率更高 那么该怎样去克隆呢? 克隆又分为浅克隆和深克隆 首先这样的方式不叫克隆 (这种只能叫做引用复制): Object obj1 = new Object()
Java编程实现对象克隆（复制）代码详解
08-28
Java编程实现对象克隆（复制）代码详解 在 Java 编程中，对象克隆是一种非常重要的技术，它允许开发者创建一个对象的副本，具有相同的属性和行为。对象克隆可以分为浅克隆和深克隆，浅克隆仅复制对象的引用，而深...
HashMap为什么线程不安全？
rnnf_yyds的博客
11-03 365
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 884
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
服务器虚拟化
Hellc007的博客
10-30 926
服务器虚拟化是一种将物理服务器的计算资源分割为多个独立虚拟环境的技术，通过软件层将底层硬件资源抽象化并在上层构建多个虚拟机（Virtual Machine, VM）。每个虚拟机运行独立的操作系统和应用程序，相互之间不受干扰，具备类似于物理服务器的功能。这种技术使得一台物理服务器能够承担多台虚拟服务器的角色，从而极大地提升了硬件资源的利用率。服务器虚拟化的概念最早可追溯到20世纪60年代IBM大型机时代，当时虚拟化被用来将大型机的资源分配给多个任务，使得企业在有限的资源下能够同时运行多个应用。
spring循环依赖解决方式
qq_36400213的博客
11-04 444
字段注入和setter注入则提供了更多的灵活性，但需要更谨慎地管理对象的状态。方法注入和注解注入则适用于特定的场景。在Spring框架中，依赖注入（Dependency Injection，DI）是一种实现控制反转（Inversion of Control，IoC）的机制，用于将对象的依赖关系自动注入到对象中。这种方式不如构造器注入严格，但比字段注入更灵活，因为它可以在不创建新实例的情况下改变对象的依赖。这种方式是推荐的，因为它可以保证对象在创建时就处于完全初始化的状态，并且可以使得bean不可变。
SpringSession源码分析
lkr_lkr的博客
11-01 307
默认对常规Session的理解和使用，如何使用Set-Cookie。
每日OJ题_牛客_相差不超过k的最多数_滑动窗口_C++_Java
最新发布
参考书籍：《C语言程序设计》《数据结构》《C++ Primer》《Effective C++》《STL源码剖析》《现代操作系统》《UNIX环境高级编程》《图解TCP/IP》《图解HTTP》《Linux高性能服务器编程》《剑指Offer》《算法导论》
11-04 165
每日OJ题_牛客_相差不超过k的最多数_滑动窗口_C++_Java（排序容易想，但是滑动窗口不容易想到，核心思想：使用滑动窗口算法通过动态调整窗口的大小，遍历所有符合条件的连续子序列，求得最大连续子序列的长度。）
Android 13 解决 Settings 首页矢量图修改颜色不生效
人生只是一种体验，不必用来演绎完美。
10-30 309
从Android 12 开始, 推出了Material You 设计，并在 Android 13 中得到了改进。导致了修改svg颜色不生效的问题。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值