java对象克隆详解

这篇具有很好参考价值的文章主要介绍了java对象克隆详解。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

概述: 当我们new一个对象时,其中的属性就会被初始化, 那么想要保存刚开始初始化的值就靠clone方法来实现, 平时我们最常见的是一个对象的引用指向另一个对象,并不是创建了两个对象.

 Person p1 = new Person(100,"jim");
        Person p2 = p1;

        System.out.println(p1==p2);//true

克隆肯定是创建了两个对象

 Person p1 = new Person(100,"jim");
        Person p2 =p1.clone();//克隆的新对象

        System.out.println(p1==p2);//false

克隆分为浅克隆(ShallowClone)和深克隆(DeepClone)。

在 Java 语言中,数据类型分为值类型(基本数据类型)和引用类型,值类型包括 int、double、byte、boolean、char 等简单数据类型,引用类型包括类、接口、数组等复杂类型。基本类型的值可以直接复制,引用类型只能复制引用地址。所以浅克隆和深克隆的主要区别在于是否支持引用类型的成员变量的复

制.

浅克隆

在浅克隆中,如果原型对象的成员变量是值类型,将复制一份给克隆对象;如果原型对象的成员变量是引用类型,则将引用对象的地址复制一份给克隆对象,也就是说原型对象和克隆对象的成员变量指向相同的内存地址。简单来说,在浅克隆中,当对象被复制时只复制它本身和其中包含的值类型的成员变量,而引用类型的成员对象并没有复制。

实现方式:

1.在 Java 语言中,通过覆盖 Object 类的 clone()方法可以实现浅克隆。

2.在 spring 框架中提供 BeanUtils.copyProperties(source,target);

这里我们主要演示通过重写object中clone方法来实现

1.首先定义一个类(需要被克隆的类)

public class Person implements  Cloneable{

     int num;
     String name;
     Address address;

    public Person() {
    }

    public Person(int num, String name) {
        this.num = num;
        this.name = name;
    }

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

    public String getName() {
        return name;
    }

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

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    @Override
    protected Person clone() throws CloneNotSupportedException {
        Person person = (Person)super.clone();
        return person;
    }

    @Override
    public String toString() {
        return "Person{" +
                "num=" + num +
                ", name='" + name + '\'' +
                ", address=" + address +
                '}';
    }
}

2.可以看到Person类关联着Address类,也写出来

public class Address  {

     String  address;

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

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

3.写一个Test类进行测试

public class Test {

    public static void main(String[] args) throws CloneNotSupportedException {

        Address address = new Address();
                address.setAddress("汉中");

        Person p1 = new  Person(100,"jim");
               p1.setAddress(address);

        Person p2 =p1.clone();
               p2.setName("tom");
               address.setAddress("西安");

        System.out.println(p1); // jim   西安
        System.out.println(p2);// tom    西安
    }
}

首先看name属性,p1的name为jim,克隆出另一个对象p2,将name改成了tom,因为是两个对象,所以输出的结果分别都不同.

再看关联对象, 首先将有汉中信息的address加入到了p1中,所以目前p1中的address是汉中,经过克隆出p2后,其实对于address来说只克隆了地址,所以说p1和p2指向的都是同一个address,所以都是汉中,再经过一次修改成了西安,所以都是西安.

所以说浅克隆只是克隆了引用类型变量的地址.

深克隆

在深克隆中,无论原型对象的成员变量是值类型还是引用类型,都将复制一份给克隆对象,深克隆将原型对象的所有引用对象也复制一份给克隆对象。简单来说,在深克隆中,除了对象本身被复制外,对象所包含的所有成员变量也将复制

在 Java 语言中,如果需要实现深克隆,可以通过覆盖 Object 类的 clone()方法实现,也可以通过序列化(Serialization)等方式来实现。序列化就是将对象写到流的过程,写到流中的对象是原有对象的一个拷贝,而原对象仍然存在于内存中。通过序列化实现的拷贝不仅可以复制对象本身,而且可以复制其引用的成员对象,因此通过序列化将对象写到一个流中,再从流里将其读出来,可以实现深克隆。需要注意的是能够实现序列化的对象其类必须实现Serializable 接口,否则无法实现序列化操作

1.重写Object类中的clone方法

1.首先定义一个类(需要被克隆的类),相比于上面的浅克隆增加了一行克隆address对象的代码

public class Person implements  Cloneable{

     int num;
     String name;
     Address address;

    public Person() {
    }

    public Person(int num, String name) {
        this.num = num;
        this.name = name;
    }

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

    public String getName() {
        return name;
    }

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

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    @Override
    protected Person clone() throws CloneNotSupportedException {
        Person person = (Person)super.clone();
        person.address = (Address)address.clone();   //深度复制  联同person中关联的对象也一同克隆.
        return person;
    }

    @Override
    public String toString() {
        return "Person{" +
                "num=" + num +
                ", name='" + name + '\'' +
                ", address=" + address +
                '}';
    }
}

2.Address写出来,相比于上面浅克隆多了一个重写Object类的clone方法

public class Address  {

     String  address;

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

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

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

3.还是Test测试类

public class Test {

    public static void main(String[] args) throws CloneNotSupportedException {

        Address address = new Address();
                address.setAddress("汉中");

        Person p1 = new  Person(100,"jim");
               p1.setAddress(address);

        Person p2 =p1.clone();
               p2.setName("tom");
               address.setAddress("西安");

        System.out.println(p1); // jim   西安
        System.out.println(p2);// tom    汉中
    }
}

这次的结果会有所不同, 因为深克隆不仅克隆了自己, 还克隆了关联着的类的对象, 所以说原来的p1存储的汉中被克隆在了p2中,而最后一行更改为西安的是原来的address对象, p2中已经克隆了原来的address并且保存了下来

2.序列化(Serialization)的方式

如果需要被克隆的类中关联的其他类的对象太多, 那么继续用深克隆的话需要耗费大量的时间去一个一个克隆关联着的对象, 而序列化的方式可以将该类中所有关联的对象化成流从而高校的进行克隆.

1.还是创建一个关联着被克隆的类的对象

public class Address  implements Serializable {

     String  address;

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

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

}

2.Person类,里面写一个自己的序列化方式的克隆方法

public class Person implements Serializable {

     int num;
     String name;
     Address address;

    public Person() {
    }

    public Person(int num, String name) {
        this.num = num;
        this.name = name;
    }

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

    public String getName() {
        return name;
    }

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

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    /**
     * 自定义克隆方法
     * @return
     */
    public Person myclone() {
            Person person = null;
              try { // 将该对象序列化成流,因为写在流里的是对象的一个拷贝,而原对象仍然存在于JVM里面。所以利用这个特性可以实现对象的深拷贝
                     ByteArrayOutputStream baos = new ByteArrayOutputStream();
                      ObjectOutputStream oos = new ObjectOutputStream(baos);
                      oos.writeObject(this);
            // 将流序列化成对象
                    ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
                     ObjectInputStream ois = new ObjectInputStream(bais);
                     person = (Person) ois.readObject();
                  } catch (IOException e) {
                     e.printStackTrace();
                  } catch (ClassNotFoundException e) {
                     e.printStackTrace();
                 }
             return person;
          }


    @Override
    public String toString() {
        return "Person{" +
                "num=" + num +
                ", name='" + name + '\'' +
                ", address=" + address +
                '}';
    }
}

3.Test类测试

public class Test {

    public static void main(String[] args) throws CloneNotSupportedException {

        Address address = new Address();
                address.setAddress("汉中");

        Person p1 = new  Person(100,"jim");
        p1.setAddress(address);

        Person p2 =p1.myclone();
               p2.setName("tom");
               address.setAddress("西安");

        System.out.println(p1);jim   西安
        System.out.println(p2);tom   汉中
    }
}

所以说, 得看具体情况进行选择文章来源地址https://www.toymoban.com/news/detail-489556.html

到了这里,关于java对象克隆详解的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 一网打尽java注解-克隆-面向对象设计原则-设计模式

    注解 :也叫标注,用于包、类、变量、方法、参数上。可以通过反射获取标注。可以在编译期间使用,也可以被编译到字节码文件中,运行时生效。 内置注解 :Java语言已经定义好的注解。 @Overread :用于方法重写。 @Deprecated :标记过时方法。 @SuppressWarnings :指示编译器去

    2024年02月11日
    浏览(44)
  • Java中的深克隆和浅克隆(Clone)

    浅克隆(shallow clone)和深克隆(deep clone)是两种不同的对象复制方法。 浅克隆会创建一个新对象,然后将原始对象的所有字段复制到新对象中。如果字段是基本类型,则它们的值将被直接复制。如果字段是引用类型,则只会复制引用,而不会复制引用指向的对象。这意味着

    2024年02月16日
    浏览(40)
  • [设计模式Java实现附plantuml源码~创建型] 对象的克隆~原型模式

    前言: 为什么之前写过Golang 版的设计模式,还在重新写 Java 版? 答:因为对于我而言,当然也希望对正在学习的大伙有帮助。Java作为一门纯面向对象的语言,更适合用于学习设计模式。 为什么类图要附上uml 因为很多人学习有做笔记的习惯,如果单纯的只是放一张图片,那

    2024年01月23日
    浏览(39)
  • Java原型模式详解:克隆人案例【深浅克隆】

    前言 在许多情况下,我们需要创建对象的副本,比如在初始化操作比较复杂或者需要大量资源的情况下。在这些情况下,我们可以使用原型模式来避免重复创建对象,提高程序的性能。本文将介绍Java中的原型模式以及如何在实际应用中使用它。 原型模式(Prototype Pattern)属

    2024年02月05日
    浏览(39)
  • Java 基础进阶篇(十七):反射概述及获取对象的方式

    反射是指对于任何一个Class类,在 “运行的时候”,不用创建对象,就可以直接得到这个类全部成分。 在运行时,可以直接得到这个类的构造器对象:Constructor 在运行时,可以直接得到这个类的成员变量对象:Field 在运行时,可以直接得到这个类的成员方法对象:Method 这种

    2024年02月07日
    浏览(38)
  • Java进阶(4)——结合类加载JVM的过程理解创建对象的几种方式:new,反射Class,克隆clone(拷贝),序列化反序列化

    1.类什么时候被加载到JVM中,new,Class.forName: Class.forName(“包名.类名”); 2.创建对象的方式,反射,本质是获得类的类对象Class; 3.克隆clone,深拷贝,浅拷贝的对比; 4.序列化和反序列化的方式; Hello h; // 此时没有用Hello,jvm并没有进行类加载 看到new : new Book() Class.forName:

    2024年02月12日
    浏览(42)
  • java的面向对象编程(oop)——static概述及初始单例设计模式

    过了入门阶段,开始学习进阶语法了。每天进步一点点,打好基础,daydayup! 什么是面向对象编程(oop),可以看这篇 java的面向对象编程(oop)概述及案例  static的意思为静态,用于修饰成员变量及成员方法。 成员变量根据有无static可以分为两种 ——类变量及实例变量 1,类

    2024年01月19日
    浏览(52)
  • 原型模式——对象的克隆

    可以通过一个原型对象克隆出多个一模一样的对象,该模式被称为原型模式。 在使用原型模式时,需要首先创建一个原型对象,再通过复制这个原型对象来创建更多同类型的对象。 原型模式(Prototype Pattern):使用原型实例指定创建对象的种类,并且通过克隆这些原型创建新

    2024年02月14日
    浏览(32)
  • Three.js教程:对象克隆、复制

    推荐:将 NSDT场景编辑器 加入你的3D工具链 其他系列工具: NSDT简石数字孪生 Threejs大多数对象都有克隆 .clone() 和复制 .copy() 两个方法,点模型 Points 、线模型 Line 、网格网格模型 Mesh 一样具有这两个方法。 A.copy(B) 表示B属性的值赋值给A对应属性。 N = M.clone() 表示返回一个和

    2024年02月08日
    浏览(47)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包