java clone

最新推荐文章于 2024-08-29 18:44:48 发布
最新推荐文章于 2024-08-29 18:44:48 发布
阅读量992 收藏
点赞数
分类专栏： Java基础 文章标签： java object class null 测试 string
 
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并没有什么特别地困难，简单讲就是创建好对象，再设置一些成员属性。
 
qj_peng
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java clone原理_详解Java中的clone方法 -- 原型模式
weixin_36275071的博客
02-17 706
Java中对象的创建clone顾名思义就是复制， 在Java语言中， clone方法被对象调用，所以会复制对象。所谓的复制对象，首先要分配一个和源对象同样大小的空间，在这个空间中创建一个新的对象。那么在java语言中，有几种方式可以创建对象呢？1 使用new操作符创建一个对象2 使用clone方法复制一个对象那么这两种方式有什么相同和不同呢？new操作符的本意是分配内存。程序执行到new操作符时，...
java clone性能比较_Java的clone方法效率问题
weixin_26872311的博客
02-13 752
在Java中，经常会需要新建一个对象，很多情况下，需要这个新建的对象和现有的某个对象保持属性一致。那么，就有两种方式来实现这个对象的构造：①通过新建一个对象，为这个对象的属性根据原有对象的属性来进行赋值②调用clone方法，来实现实例对象的克隆对于Java的clone方法，需要注意的就是它实际上是一种“浅克隆”(Shallow Clone)，对于int、double这种基本数据类型，直接拷贝值；对...
java string clone_Java Clone深拷贝与浅拷贝的两种实现方法
weixin_35344136的博客
02-13 891
1.首先，你要知道怎么实现克隆：实现Cloneable接口，在bean里面重写clone()方法，权限为public。2.其次，你要大概知道什么是地址传递，什么是值传递。3.最后，你要知道你为什么使用这个clone方法。先看第一条，简单的克隆代码的实现。这个也就是我们在没了解清楚这个Java的clone的时候，会出现的问题。看完代码，我再说明这个时候的问题。先看我要克隆的学生bean的代码：pac...
java clone 父类_Java中的克隆(Clone)机制 .
weixin_30884743的博客
02-16 634
Java中的克隆(Clone)机制现在Clone已经不是一个新鲜词语了，伴随着“多莉”的产生这个词语确实很“火”过一阵子，在java中也有这么一个概念，它可以让我们很方便的“制造”出一个对象的副本来，下面来具体看看java中的Clone机制是如何工作的？1． Clone()方法的使用Clone()方法的使用比较简单，注意如下几点即可：a． 什么时候使用shallow Clone，什么时候使用dee...
java clone原理_cloneAble接口实现clone()原理
weixin_42499586的博客
02-17 1256
java的克隆分为深克隆和浅克隆：了解克隆clone我们必须要了解1.首先，要了解什么是克隆，怎么实现克隆。2.其次，你要大概知道什么是地址传递，什么是值传递。3.最后，你要知道你为什么使用这个clone方法Cloneable接口的作用：Object类中的clone()是protected的方法，在没有重写Object的clone()方法且没有实现Cloneable接口的实例上调用clone方法，...
java clone 对象_Java中创建对象的5种方式
weixin_42144707的博客
02-12 521
原标题：Java中创建对象的5种方式作为Java开发者，我们每天创建很多对象，但我们通常使用依赖管理系统，比如Spring去创建对象。然而这里有很多创建对象的方法，我们会在这篇文章中学到。Java中有5种创建对象的方式，下面给出它们的例子还有它们的字节码使用new关键字} → 调用了构造函数使用Class类的newInstance方法} → 调用了构造函数使用Constructor类的newIns...
java clone protected_java中的clone方法（）为什么定义成 Protected而并非 public
weixin_35785014的博客
02-16 641
说句题外话，书真的是书读百遍其义自见。当然读的时候也要想。之前阅读时不曾注意到的细节，都能映入眼帘。好了开始正题：clone()方法是定义在Object中的方法 并定义为:protected native Object() throws cloneNotSupportedException;在使用时clone()方法时，你首先必须使该对象所在类实现接口clonable,否则会抛出上述异常。而在Ja...
Java clone
Mazai-Liu的博客
05-07 288
java中的深浅克隆
java clone 父类_Java：super.clone（）方法和继承
weixin_36410904的博客
02-13 711
小编典典听起来这里至少有两个问题在起作用：听起来您对clone()的正常实现方式感到困惑。听起来您好像在想克隆是个好主意(与使用复制构造函数，工厂或其等效对象相比)。这是克隆方法的实现示例：@Overridepublic Object clone() throws CloneNotSupportedException {//get initial bit-by-bit copy, which ha...
Java clone方法详解及简单实例
08-31
Java中的`clone`方法是Java语言提供的一种复制对象的机制，它允许创建一个现有对象的副本，这个副本具有与原始对象相同的状态，但它们是独立的实体，对其中一个对象的修改不会影响另一个。`clone`方法是Java `Object...
Java Clone(类的复制)实例代码
09-05
在Java编程语言中，`Clone`机制是一种创建对象副本的方法，它允许我们创建一个与原始对象具有相同数据的新对象。通常，当我们需要在程序中复制一个对象时，但又不希望影响原始对象的状态，`Clone`操作就显得非常有用...
启动Application 报错：no mapping for GET /（已解决）
qq_3512323979的博客
08-26 2251
no mapping for GET /因为我使用的是框架嘛，然后生成了一个SpringBoot项目后，resources下面就会有一个static的类，用于存放静态资源类，后面我把静态资源放在里面，但是启动启动类后，报错一直匹配不到。： 正常的话，我们使用SpringBoot框架，他会给我们提供许多便利，包括静态资源的自动服务，默认的话，他会去。报这个错可能还有其他原因，我的是因为这个，大家可以根据日志信息一步步检查，肯定可以解决的！类并覆盖其方法时，就会失去静态资源的自动服务
《深入理解 Java 中的适配器模式》
最新发布
面团到油条的成长日记
08-29 857
在软件开发的广阔领域中，不同接口之间不匹配的问题时常像个棘手的难题困扰着开发者。而适配器模式就像是一位得力的助手，专门用来解决这类问题。它的关键作用在于把一个类的接口有效地转化为客户端所期望的另一种接口，让原本因接口不相符而不能一起工作的两个类可以共同协作，学习本文希望你能有所收获
linux上datax 安装以及使用
寂夜了无痕的博客
08-24 2890
linux上datax 安装以及使用
Java设计模式之建造者模式详细讲解和案例示范
weixin_39996520的博客
08-28 783
建造者模式是一种创建型设计模式，允许用户通过一步步地构造复杂对象的方式来避免直接使用大量的构造函数或复杂的初始化过程。它通过将对象的创建过程分解为多个步骤，并允许这些步骤以链式调用的方式来执行，最终生成一个完全构建的对象。首先，我们定义一个Order类，该类包括了多个字段，如订单ID、客户信息、商品列表、配送地址等。// Getter方法省略...在这个例子中，类提供了构建Order对象所需的各个方法，每个方法返回实例，以便进行链式调用。
操作系统原子操作
zzt_is_me的博客
08-28 1150
所谓的原子操作就是不可被拆分的操作，对于多线程对全局变量进行操作时，就再也不用再线程锁了，和pthread_mutex_t保护作用是一样的，也是线程安全的，有些编译器在使用时需要加-march=i686编译参数。2、type只能是整数相关的类型，浮点型和自定义类型无法使用。功能：把value赋值给*ptr,并返回*ptr的旧值。功能：以上操作返回的是*ptr与value计算后的值。使用原子操作实现一个线程安全的无锁队列。1、该功能并不通用，有些编译器不支持。功能：以上操作返回的是*ptr的旧值。
java clone
09-07
在Java中，对象克隆可以通过两种方式实现：浅克隆和深克隆。 浅克隆是指创建一个新的对象，该对象的字段与原始对象相同。但如果字段是引用类型，那么新对象与原始对象将引用相同的引用类型对象。换句话说，新对象和原始对象共享相同的引用类型字段，对其中一个对象所做的更改会影响另一个对象。 要实现浅克隆，需要在要克隆的类中实现Cloneable接口，并重写Object类的clone()方法。以下是一个示例： ```java public class MyClass implements Cloneable { private int myField; public Object clone() throws CloneNotSupportedException { return super.clone(); } // 其他代码... } ``` 使用浅克隆时，可以通过调用clone()方法来创建一个新对象： ```java MyClass original = new MyClass(); MyClass clone = (MyClass) original.clone(); ``` 深克隆是指创建一个新的对象，并且递归地克隆其所有字段，包括引用类型字段。这样，新对象与原始对象完全独立，对其中一个对象所做的更改不会影响另一个对象。 要实现深克隆，需要在要克隆的类中实现Serializable接口，并使用序列化和反序列化来实现深复制。以下是一个示例： ```java import java.io.*; public class MyClass implements Serializable { private int myField; private MyReferenceType reference; public Object deepClone() throws IOException, ClassNotFoundException { ByteArrayOutputStream bos = new ByteArrayOutputStream(); ObjectOutputStream out = new ObjectOutputStream(bos); out.writeObject(this); ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray()); ObjectInputStream in = new ObjectInputStream(bis); return in.readObject(); } // 其他代码... } ``` 使用深克隆时，可以通过调用deepClone()方法来创建一个新对象： ```java MyClass original = new MyClass(); MyClass clone = (MyClass) original.deepClone(); ``` 需要注意的是，深克隆要求对象及其引用类型字段都必须实现Serializable接口。而且，深克隆可能会影响性能，因为它涉及序列化和反序列化的过程。因此，在使用克隆时需要谨慎考虑其适用性和性能影响。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值