java clone

最新推荐文章于 2025-08-06 16:23:50 发布
转载 最新推荐文章于 2025-08-06 16:23:50 发布 · 1k 阅读 · 0
文章标签：

#java #object #class #null #测试 #string

本文详细介绍了Java中对象克隆的基本原理及实现方法，包括浅克隆与深克隆的区别，并通过具体实例展示了如何实现这两种克隆。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

 
java clone
有时我们确实需要clone一个对象，最好的方法还是使用Object的clone方法，由jdk调用native方法来实现，这样效率比较高。先来个shallow clone，再来deep clone。
 
shallow clone
 
 
代码如下：
待clone的对象
 
package practisejava.others.clone;
 
/**
 * 待clone的对象，必须实现Cloneable这个tag interface
 */
public class ObjectToClone implements Cloneable{
   private int i=0;
 
   public void setNum(int i){
       this.i=i;
   }
 
   public int getNum(){
       return this.i;
   }
  
   public void tellNum(){
       System.out.println("the number is "+i);
   }
   // 重写Object的clone
   public Object clone() throws CloneNotSupportedException {
        return (ObjectToClone)super.clone();
    }
}
clone测试
 
package practisejava.others.clone;
 
/**
 * 测试clone是否成功
 */
public class CloneTest {
    public static void main(String[] args) {
        ObjectToClone otc = new ObjectToClone();
        otc.setNum(888);
      
        // 开始clone了！
        ObjectToClone cloneObject = null;
        try {
            cloneObject = (ObjectToClone) otc.clone();
        } catch (CloneNotSupportedException ex) {
            System.out.println("Sorry,Clone Not Supported!");
        }
      
        // 测试clone是否成功
        if(cloneObject!=null){
            System.out.println("before clone");
            System.out.println("ObjectToClone get number : " + otc.getNum()+"/n");
      
            System.out.println("after clone");
            System.out.println("ObjectToClone get number : " + otc.getNum());
          
            cloneObject.setNum(999);
            System.out.println("CloneObject get number : " + cloneObject.getNum());
        }      
    }
}
执行结果
 
before clone
ObjectToClone get number : 888
 
after clone
ObjectToClone get number : 888
CloneObject get number : 999
 
 
 
从运行结果看，修改了clone体的值并没有影响到原来被clone体的值，哈哈，clone成功。高兴得太早了，ObjectToClone里只有简单的非引用属性，如果有引用的属性，还能成吗？答案是否定的！看下面的例子：
被clone对象引用的对象
 
package practisejava.others.shallowclone;
 
public class ReferencedObject {
    private int i = 0;
    public ReferencedObject(int i) {
        this.i = i;
    }
    public void doubleValue(){
        this.i = 2*this.i;
    }
  
    public int getNumber(){
        return this.i;
    }
}
 
 
待clone对象
 
package practisejava.others.shallowclone;
 
/**
 * 必须实现Cloneable接口，否则调用函数的clone方法时会报CloneNotSupportedException错
 */
public class ObjectForShallowClone implements Cloneable{
    private int i = 0;
    private ReferencedObject rf = null;
  
    public void setNum(int i) {
        this.i = i;
    }
  
    public void setReferencedObject(ReferencedObject rf){
        this.rf = rf;
    }
      
    public int getNumber(){
        return this.i;
    }
  
    public ReferencedObject getReferencedObject(){
        return this.rf;
    }
  
    // 重写Object的clone
    public Object clone() throws CloneNotSupportedException {
         return (ObjectForShallowClone)super.clone();
     }
}  
clone测试
 
package practisejava.others.shallowclone;
 
/**
 * clone测试
 */
public class CloneTest {
    public static void main(String[] args) {
        ObjectForShallowClone ofsc = new ObjectForShallowClone();
        ofsc.setNum(888);
        ofsc.setReferencedObject(new ReferencedObject(1));
 
        // 开始clone了！
        ObjectForShallowClone deepCloneObject = null;
        try {
            deepCloneObject = (ObjectForShallowClone) ofsc.clone();
        } catch (CloneNotSupportedException ex) {
            System.out.println("Sorry,Clone Not Supported!");
        }
 
        // 测试clone是否成功
        if(deepCloneObject!=null){
            System.out.println("before clone");
            System.out.println("ObjectForShallowClone get number : " + ofsc.getNumber());
            System.out.println("ObjectForShallowClone ReferencedObject get number : "+ofsc.getReferencedObject().getNumber()+"/n");
          
            deepCloneObject.setNum(999);
            deepCloneObject.getReferencedObject().doubleValue();
 
            System.out.println("after clone");
            System.out.println("ObjectForShallowClone get number : " + ofsc.getNumber());
            System.out.println("ObjectForShallowClone ReferencedObject get number : " + ofsc.getReferencedObject().getNumber());
 
            System.out.println("CloneObject get number : " + deepCloneObject.getNumber());
            System.out.println("CloneObject ReferencedObject get number : " + deepCloneObject.getReferencedObject().getNumber());
        }      
    }
}
 
运行结果如下：
 
before clone
ObjectForShallowClone get number : 888
ObjectForShallowClone ReferencedObject get number : 1
 
after clone
ObjectForShallowClone get number : 888
ObjectForShallowClone ReferencedObject get number : 2
CloneObject get number : 999
CloneObject ReferencedObject get number : 2
 
 
 
显然，修改了clone对象的引用对象的值后，被clone对象引用对象的值也随之改变。这不是我们想要的效果，改进的方法就是deep clone。
deep clone
被clone对象引用的对象（比shallow clone多加了clone的方法）
 
package practisejava.others.deepclone;
 
public class ReferencedObject implements Cloneable{
    private int i = 0;
    public ReferencedObject(int i) {
        this.i = i;
    }
    public void doubleValue(){
        this.i = 2*this.i;
    }
 
    public int getNumber(){
        return this.i;
    }
 
    // 重写clone的方法
    public Object clone() throws CloneNotSupportedException {
        return (ReferencedObject)super.clone();
    }
}
待clone对象(在clone方法里同时clone引用对象)
 
package practisejava.others.deepclone;
 
import practisejava.others.deepclone.ReferencedObject;
 
public class ObjectForDeepClone implements Cloneable{
    private int i = 0;
    private ReferencedObject rf = null;
 
    public void setNum(int i) {
        this.i = i;
    }
 
    public void setReferencedObject(ReferencedObject rf){
        this.rf = rf;
    }
 
    public int getNumber(){
        return this.i;
    }
 
    public ReferencedObject getReferencedObject(){
        return this.rf;
    }
    // 重写Object的clone
    public Object clone() throws CloneNotSupportedException {
         ObjectForDeepClone cloneObject = (ObjectForDeepClone)super.clone();
         // 调用引用对象的clone方法
         if(rf!=null){
             ReferencedObject rfClone = (ReferencedObject)rf.clone();
             cloneObject.setReferencedObject(rfClone);
         }
         return cloneObject;
     }
}
clone测试
 
package practisejava.others.deepclone;
 
public class CloneTest {
    public static void main(String[] args) {
        ObjectForDeepClone ofdc = new ObjectForDeepClone();
        ofdc.setNum(888);
        ofdc.setReferencedObject(new ReferencedObject(1));
 
        // 开始clone了！
        ObjectForDeepClone deepCloneObject = null;
        try {
            deepCloneObject = (ObjectForDeepClone) ofdc.clone();
        } catch (CloneNotSupportedException ex) {
            System.out.println("Sorry,Clone Not Supported!");
        }
 
        // 测试clone是否成功
        if(deepCloneObject!=null){
            System.out.println("before clone");
            System.out.println("ObjectForDeepClone get number : " + ofdc.getNumber());
            System.out.println("ObjectForDeepClone ReferencedObject get number : "+ofdc.getReferencedObject().getNumber()+"/n");
 
            deepCloneObject.setNum(999);
            deepCloneObject.getReferencedObject().doubleValue();
 
            System.out.println("after clone");
            System.out.println("ObjectForDeepClone get number : " + ofdc.getNumber());
            System.out.println("ObjectForDeepClone ReferencedObject get number : " + ofdc.getReferencedObject().getNumber());
 
            System.out.println("CloneObject get number : " + deepCloneObject.getNumber());
            System.out.println("CloneObject ReferencedObject get number : " + deepCloneObject.getReferencedObject().getNumber());
        }
    }
}
 
 
 
 
 
运行结果：
 
before clone
ObjectForDeepClone get number : 888
ObjectForDeepClone ReferencedObject get number : 1
 
after clone
ObjectForDeepClone get number : 888
ObjectForDeepClone ReferencedObject get number : 1
CloneObject get number : 999
CloneObject ReferencedObject get number : 2
 
 
 
Clone通常有两种类型即浅clone和深clone。首先，分析一下两种的不同。浅clone和深clone都是clone，它们本质区别是对象内部的成员属性（非原生类型属性，如int等）在clone时是否处理为引用。如果仍然保留为引用，则称为浅clone，反之称为深clone。其实这两个概念也是相对的概念。在处理上它们有点区别，浅clone方式得到clone对象即可，深clone方式在得到clone对象后，还需要对引用的成员属性进行“clone”处理。从这个层次上说，深clone并没有什么特别地困难，简单讲就是创建好对象，再设置一些成员属性。
 
Java clone
Mazai-Liu的博客
05-07 327
java中的深浅克隆
java clone 效率_Java中的Clone
weixin_36089954的博客
02-27 297
参考：https://juejin.im/entry/5bafa3d66fb9a05cff322691总结：1、如果想要支持clone，就需要实现Cloneable 接口2、如果没有实现Cloneable接口的调用clone方法，会抛出CloneNotSupportedException异常。3、重写clone方法，并修改成public访问级别深拷贝：1、使用默认的clone方法2、对于原始数据域...
java clone() 方法详解
T_Y_F_的博客
11-22 1352
方法已逐渐不被推荐，开发者更多选择自定义的方式实现对象拷贝，以获得更好的控制和代码清晰度。方法中手动实现，确保所有引用类型字段都被克隆成独立的对象。通过提供一个接收同类对象的构造函数，实现对象复制。它通过浅拷贝创建一个对象的副本，是。：通过手动克隆引用类型字段，成功实现深拷贝。方法是 Java 提供的一种用于。通过对象序列化和反序列化实现深拷贝。在 Java 的现代开发中，
Java Clone
程序猿_三产
03-24 453
Java类自带了本地的clone()方法，该方法会返回现有实例的副本。如果要使用Java克隆，必须实现java.lang.Cloneable接口，以便它不会在运行时抛出CloneNotSupportedException。 如果clone()函数会返回对象副本，那么在什么情况下我们需要重写它？ 让我们运行下面的java类来更好的理解。import java.util.HashMap; impor
java clone原理_详解Java中的clone方法 -- 原型模式
weixin_36275071的博客
02-17 802
Java中对象的创建clone顾名思义就是复制， 在Java语言中， clone方法被对象调用，所以会复制对象。所谓的复制对象，首先要分配一个和源对象同样大小的空间，在这个空间中创建一个新的对象。那么在java语言中，有几种方式可以创建对象呢？1 使用new操作符创建一个对象2 使用clone方法复制一个对象那么这两种方式有什么相同和不同呢？new操作符的本意是分配内存。程序执行到new操作符时，...
java clone性能比较_Java的clone方法效率问题
weixin_26872311的博客
02-13 851
在Java中，经常会需要新建一个对象，很多情况下，需要这个新建的对象和现有的某个对象保持属性一致。那么，就有两种方式来实现这个对象的构造：①通过新建一个对象，为这个对象的属性根据原有对象的属性来进行赋值②调用clone方法，来实现实例对象的克隆对于Java的clone方法，需要注意的就是它实际上是一种“浅克隆”(Shallow Clone)，对于int、double这种基本数据类型，直接拷贝值；对...
java clone 父类_Java中的克隆(Clone)机制 .
weixin_30884743的博客
02-16 740
Java中的克隆(Clone)机制现在Clone已经不是一个新鲜词语了，伴随着“多莉”的产生这个词语确实很“火”过一阵子，在java中也有这么一个概念，它可以让我们很方便的“制造”出一个对象的副本来，下面来具体看看java中的Clone机制是如何工作的？1． Clone()方法的使用Clone()方法的使用比较简单，注意如下几点即可：a． 什么时候使用shallow Clone，什么时候使用dee...
java的clone
gulanga5的博客
06-04 428
如果具有引用类型成员变量的类，此时若需要进行深克隆，则需要重写了clone方法，并在clone方法中调用引用类型成员变量的clone方法对引用类型变量指向的对象都进行克隆。如果具有引用类型成员变量的类，单纯的重写了clone方法。则调用clone方法进行对象克隆时就是浅克隆(只是克隆了此类对象，内部的引用类型属性指向的对象没有被克隆)。
java string clone_Java Clone深拷贝与浅拷贝的两种实现方法
weixin_35344136的博客
02-13 960
1.首先，你要知道怎么实现克隆：实现Cloneable接口，在bean里面重写clone()方法，权限为public。2.其次，你要大概知道什么是地址传递，什么是值传递。3.最后，你要知道你为什么使用这个clone方法。先看第一条，简单的克隆代码的实现。这个也就是我们在没了解清楚这个Java的clone的时候，会出现的问题。看完代码，我再说明这个时候的问题。先看我要克隆的学生bean的代码：pac...
Java Clone深拷贝与浅拷贝的两种实现方法
08-26
Java Clone 深拷贝与浅拷贝的两种实现方法 Java Clone 是 Java 语言中的一种复制对象的机制，它可以将一个对象的所有属性和状态复制到另一个对象中，实现对象的深拷贝和浅拷贝。下面我们将讨论 Java 中的深拷贝和浅...
Java clone方法详解及简单实例
08-31
Java中的`clone`方法是Java语言提供的一种复制对象的机制，它允许创建一个现有对象的副本，这个副本具有与原始对象相同的状态，但它们是独立的实体，对其中一个对象的修改不会影响另一个。`clone`方法是Java `Object...
Java Clone(类的复制)实例代码
09-05
在Java编程语言中，`Clone`机制是一种创建对象副本的方法，它允许我们创建一个与原始对象具有相同数据的新对象。通常，当我们需要在程序中复制一个对象时，但又不希望影响原始对象的状态，`Clone`操作就显得非常有用...
需求EAV模型的优化与思考
最新发布
HAN_789的博客
08-06 447
针对EAV（Entity-Attribute-Value）存储模型及Elasticsearch集成需求，以下是详细方案设计和实现建议。
Java中的RabbitMQ完全指南
H1658554092的博客
07-31 1051
Java中的RabbitMQ完全指南
Flash循环存储的地址回绕处理：跨边界写入的三种实现方案
u010360138的博客
08-05 1157
本文介绍了三种实现Flash循环存储地址计算的方法：1）条件判断法通过显式判断是否溢出实现地址回绕，逻辑清晰通用性强；2）模运算法利用取模运算自动处理地址回绕，代码简洁；3）位掩码法在存储区大小为2的幂时使用位与运算替代模运算，性能最优。三种方法功能等效但各有特点，选择时应考虑存储区特性、性能需求和代码可读性。关键注意事项包括写入延迟、地址有效性检查和边界条件处理。
基于Java的AI/机器学习库（Smile、Weka、DeepLearning4J）的实用
keny-大成的博客
08-04 945
在Java中定义AI动作，通常涉及枚举或常量类来列举可识别的合理动作。挥手（WAVE）点头（NOD）摇头（SHAKE_HEAD）鼓掌（CLAP）举手（RAISE_HAND）叉腰（HANDS_ON_HIPS）抱臂（CROSS_ARMS）指向前方（POINT_FORWARD）竖起大拇指（THUMBS_UP）竖起小拇指（THUMBS_DOWN）比心（HAND_HEART）敬礼（SALUTE）握拳（FIST）张开双手（OPEN_HANDS）双手合十（PRAY）
菜鸟集团招Java研发啦
jobleap.cn求职助手首页
08-04 482
菜鸟集团招聘JAVA研发工程师，工作地点杭州。岗位职责包括分布式系统开发、高性能服务端程序设计、搜索引擎模块实现及海量数据处理。要求精通JAVA等编程语言，熟悉网络编程、Linux环境和数据库技术，具备扎实的算法基础。优先考虑有互联网实习经历、ACM竞赛获奖或学术成果的候选人。该职位面向具备良好学习能力和团队协作精神的技术人才。
java clone
09-07
在Java中，对象克隆可以通过两种方式实现：浅克隆和深克隆。 浅克隆是指创建一个新的对象，该对象的字段与原始对象相同。但如果字段是引用类型，那么新对象与原始对象将引用相同的引用类型对象。换句话说，新对象和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值