Java Object的clone方法分析

最新推荐文章于 2023-05-15 18:02:37 发布
最新推荐文章于 2023-05-15 18:02:37 发布
阅读量574 收藏
点赞数 1
分类专栏： Java 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yeyulemon/article/details/121968842
版权

学习视频：https://study.163.com/course/introduction/1006177009.htm

学习目标

  1. 能够理解clone方法的由来
  2. 能够使用clone方法创建对象
  3. 能够理解克隆对象和原对象的关系
  4. 能够理解clone方法创建对象与new关键字和反射创建对象的不同
  5. 能够理解浅表复制和深层复制的含义
  6. 能够探寻对象的复制必须实现Cloneable接口的底层源码

1. 克隆方法的由来

问题一：什么是克隆(clone)方法？
答：创建并返回此对象的一个副本–按照原对象，创建一个新对象(复制原对象的内容)。

问题二：已经存在new关键字和反射技术都可以创建对象，为什么还需要一个Object的clone方法呢？
答：必然是new关键字和 反射技术，存在一些弊端。看下面的例子体会弊端在哪。

1.1 new关键字和反射创建对象的弊端

我们来看一个需求：使用new关键字和反射创建内容一模一样的对象，并且打印它们的哈希值。
演示素材–Person：

package com.yynm.pojo;

/**
 * @Description: Person实体类
 * @Author: yeyulemon
 * @Date: 2021-12-16 21:06
 **/
public class Person {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

演示Person类使用new关键字和反射创建内容一模一样的对象，并且打印它们的哈希值

/**
 * @Description: 使用new关键字和反射创建内容一模一样的对象，并且打印它们的哈希值
 * @Param: []
 * @return: void
 * @Author: yeyulemon
 * @Date: 2021/12/16 21:12
 */
@Test
public void test01() throws Exception {
    Person person1 = new Person();
    person1.setName("张三");
    person1.setAge(18);

    Person person2 = new Person();
    person2.setName("张三");
    person2.setAge(18);

    System.out.println(person1 + ":" + person1.hashCode());
    System.out.println(person2 + ":" + person2.hashCode());

    Class clazz = Class.forName("com.yynm.pojo.Person");
    Person person3 = (Person) clazz.getConstructor().newInstance();
    person3.setName("张三");
    person3.setAge(18);

    Person person4 = (Person) clazz.getConstructor().newInstance();
    person4.setName("张三");
    person4.setAge(18);

    System.out.println(person3 + ":" + person3.hashCode());
    System.out.println(person4 + ":" + person4.hashCode());
}

效果

com.yynm.pojo.Person@dc24521:230835489
com.yynm.pojo.Person@10bdf5e5:280884709
com.yynm.pojo.Person@6e1ec318:1847509784
com.yynm.pojo.Person@7e0b0338:2114650936

总结：通过new和反射可以创建内容一模一样的对象。但是，创建对象之后，通过setter方法设置一模一样的内容，如果需要创建更多内容一致的对象，那么就需要调用非常多的setter方法。

接下来，使用Object的clone方法演示，更加简便快捷，复制对象的操作！

1.2 使用clone方法创建对象

1.2.1 使用步骤
  1. 在需要clone方法的类上实现Cloneable接口
  2. 重写clone方法，在自己的clone方法中调用父类的clone方法，将返回值类型强转成本类类型，将当前clone方法修饰符改为public
  3. 在测试中调用对象的clone方法
1.2.2 代码演示
  1. 在需要clone方法的类上实现Cloneable接口
  2. 重写clone方法，在自己的clone方法中调用父类的clone方法，将返回值类型强转成本类类型，将当前clone方法修饰符改为public
package com.yynm.pojo;

/**
 * @Description: Person实体类
 * @Author: yeyulemon
 * @Date: 2021-12-16 21:06
 **/
public class Person implements Cloneable {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

    @Override
    public Person clone() throws CloneNotSupportedException {
        return (Person) super.clone();
    }
}
  1. 在测试中调用对象的clone方法
/** 
* @Description: 在测试中调用对象的clone方法
* @Param: [] 
* @return: void 
* @Author: yeyulemon 
* @Date: 2021/12/16 21:33 
*/
@Test
public void test02() throws Exception {
    Person person1 = new Person();
    person1.setName("张三");
    person1.setAge(18);

    Person person2 = person1.clone();

    System.out.println(person1 + ":" + person1.hashCode());
    System.out.println(person2 + ":" + person2.hashCode());
}

效果

com.yynm.pojo.Person@dc24521:230835489
com.yynm.pojo.Person@10bdf5e5:280884709

总结：通过使用clone方法，我们发现大大的减少了创建重复对象代码。这也就是clone方法存在的意义。

2. 克隆出来的对象和原来的对象有什么关系

通过上面的测试，我们已经知道了，克隆出来的对象内容一致，但是对象哈希值不一样，所以是不同对象。那么两个对象的内容之间有什么关联呢？两个对象的内容是彼此独立，还是，两个对象底层使用的同一个内容呢？
素材(新Person)：

package com.yynm.pojo;

/**
 * @Description: Person实体类
 * @Author: yeyulemon
 * @Date: 2021-12-16 21:06
 **/
public class Person implements Cloneable {
    private String name;
    private Integer age;
    private Children children;

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

    public Children getChildren() {
        return children;
    }

    public void setChildren(Children children) {
        this.children = children;
    }

    @Override
    public Person clone() throws CloneNotSupportedException {
        return (Person) super.clone();
    }
}

素材(新Children)：

package com.yynm.pojo;

/**
 * @Description: Children实体类
 * @Author: yeyulemon
 * @Date: 2021-12-16 21:49
 **/
public class Children {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

测试代码：

/**
* @Description: 测试克隆对象和原对象之间成员变量的联系
 * @Param: []
 * @return: void
 * @Author: yeyulemon
 * @Date: 2021/12/16 21:51
 */
@Test
public void test03() throws Exception {
    Person person1 = new Person();
    person1.setName("张三");
    person1.setAge(18);
    Children children = new Children();
    children.setName("李四");
    children.setAge(18);
    person1.setChildren(children);

    Person person2 = person1.clone();

    System.out.println(person1 + ":" + person1.hashCode() + ";" + children + ":" +person1.getChildren().hashCode());
    System.out.println(person2 + ":" + person2.hashCode() + ";" + children + ":" +person2.getChildren().hashCode());
}

效果：

com.yynm.pojo.Person@10bdf5e5:280884709;com.yynm.pojo.Children@6e1ec318:1847509784
com.yynm.pojo.Person@7e0b0338:2114650936;com.yynm.pojo.Children@6e1ec318:1847509784

结论：通过测试发现克隆出来的对象虽然不一致，但是底层的成员变量的哈希值是一致的。
这种复制我们称之为：浅表复制。
浅表复制内存结构：
浅表复制内存结构

3. 能不能让克隆出来的对象其中成员变量也变成新对象

3.1 浅表复制的弊端

由于浅表复制导致克隆的对象中成员变量的底层哈希值一致，如果我们操作其中一个对象的成员变量内容，就会导致所有的克隆对象的成员变量内容发生改变。
测试代码：

@Test
public void test04() throws Exception {
    Person person1 = new Person();
    Children children = new Children();
    children.setName("张三");
    children.setAge(18);
    person1.setChildren(children);
    Person person2 = person1.clone();
    System.out.println(person1 + ":" + person1.hashCode() + ";" + person1.getChildren().getName());
    System.out.println(person2 + ":" + person2.hashCode() + ";" + person2.getChildren().getName());
    children.setName("李四");
    children.setAge(18);
    System.out.println(person1 + ":" + person1.hashCode() + ";" + person1.getChildren().getName());
    System.out.println(person2 + ":" + person2.hashCode() + ";" + person2.getChildren().getName());
}

效果：

com.yynm.pojo.Person@573fd745:1463801669;张三
com.yynm.pojo.Person@15327b79:355629945;张三
com.yynm.pojo.Person@573fd745:1463801669;李四
com.yynm.pojo.Person@15327b79:355629945;李四

结论：clone方法默认的赋值操作是浅表复制，浅表复制存在弊端–仅仅创建新的对象，对象的成员内容底层哈希值是一致的，因此，不管是原对象还是克隆对象，只有其中一个修改了成员的数据，就会影响所有的原对象和克隆对象。
要解决浅表复制的问题：进行深层的复制。

3.2 深层复制

目的：不仅在执行克隆的时候，克隆对象是一个新对象，而且，克隆对象中的成员变量，也要求是一个新的对象。

3.2.1 开发步骤
  1. 修改Children类实现Cloneable接口
  2. 修改Children类重写clone方法
  3. 修改Person类重写clone方法，在clone方法中调用children的clone方法
3.2.2 代码实现
  1. 修改Children类实现Cloneable接口
  2. 修改Children类实现clone方法
    Children类：
package com.yynm.pojo;

/**
 * @Description: Children实体类
 * @Author: yeyulemon
 * @Date: 2021-12-16 21:49
 **/
public class Children implements Cloneable {
    private String name;
    private Integer age;

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    @Override
    public Children clone() throws CloneNotSupportedException {
        return (Children) super.clone();
    }
}

Person类：

package com.yynm.pojo;

/**
 * @Description: Person实体类
 * @Author: yeyulemon
 * @Date: 2021-12-16 21:06
 **/
public class Person implements Cloneable {
    private String name;
    private Integer age;
    private Children children;

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

    public Children getChildren() {
        return children;
    }

    public void setChildren(Children children) {
        this.children = children;
    }

    @Override
    public Person clone() throws CloneNotSupportedException {
         Person personClone = (Person) super.clone();
         personClone.setChildren(this.children.clone());
        return personClone;
    }
}

测试代码：

@Test
public void test05() throws Exception {
    Person person1 = new Person();
    Children children = new Children();
    children.setName("张三");
    children.setAge(18);
    person1.setChildren(children);
    Person person2 = person1.clone();
    System.out.println(person1 + ":" + person1.hashCode() + ";" + person1.getChildren().hashCode());
    System.out.println(person2 + ":" + person2.hashCode() + ";" + person2.getChildren().hashCode());
}

效果：

com.yynm.pojo.Person@573fd745:1463801669;355629945
com.yynm.pojo.Person@4f2410ac:1327763628;1915503092

深层复制内存结构：
在这里插入图片描述

4. 使用clone接口实现深层复制的弊端

4.1 使用clone接口实现深层复制的弊端

以上的方法虽然完成了深层复制，但是修改类中成员变量对应的源码，如果成员变量特别多，那么就需要修改多个类的源码。
例如以下代码，我们就需要修改两个成员变量对应类的源码(Children，Grandson)：

package com.yynm.pojo;

/**
 * @Description: Person实体类
 * @Author: yeyulemon
 * @Date: 2021-12-16 21:06
 **/
public class Person implements Cloneable {
    private String name;
    private Integer age;
    private Children children;
    private Grandson grandson;

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

    public Children getChildren() {
        return children;
    }

    public void setChildren(Children children) {
        this.children = children;
    }

    public Grandson getGrandson() {
        return grandson;
    }

    public void setGrandson(Grandson grandson) {
        this.grandson = grandson;
    }

    @Override
    public Person clone() throws CloneNotSupportedException {
        Person personClone = (Person) super.clone();
        personClone.setChildren(this.children.clone());
        personClone.setGrandson(this.grandson.clone());
        return personClone;
    }
}

结论：使用克隆接口完成深度复制的弊端：

1. 重复实现Cloneable接口
2. 重复实现clone方法
3. 重复改写Person类的clone方法

可以使用IO流的方式进行复制操作(深度复制)，可以解决重复修改源代码的问题。

4.2 使用IO进行克隆复制(深度复制)

4.2.1 使用IO复制相关的API介绍

1、ByteArrayOutputStream
ByteArrayOutputStream API
构造方法：
ByteArrayOutputStream 构造方法
2、ByteArrayInputStream
ByteArrayInputStream API
构造方法：
ByteArrayInputStream 构造方法
3、ObjectOutputStream
ObjectOutputStream API
构造方法：
ObjectOutputStream 构造方法
将对象写入流的方法：
将对象写入流的方法
4、ObjectInputStream
ObjectInputStream API
构造方法：
ObjectInputStream 构造方法
要调用的方法：
要调用的方法
简单演示：一个对象的复制。
开发步骤：

  1. 创建ByteArrayOutputStream，将数据可以转换成字节
  2. 创建ObjectOutputStream，关联ByteArrayOutputStream
  3. 使用ObjectOutputStream的writeObject方法，读取要复制的对象
  4. 使用ByteArrayInputStream读取ByteArrayOutputStream的转化的对象字节数据
  5. 创建ObjectInputStream并用readObject读取对象字节数据返回新对象
    素材User类：
package com.yynm.pojo;

import java.io.Serializable;

/**
 * @Description:
 * @Author: yeyulemon
 * @Date: 2021-12-19 20:09
 **/
public class User implements Serializable {
    private String username;
    private String password;

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

测试：

@Test
public void test06() throws Exception {
    User user1 = new User();
    user1.setUsername("张三");
    user1.setPassword("123456");

    // 1. 创建ByteArrayOutputStream，将数据可以转换成字节
    ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
    // 2. 创建ObjectOutputStream，关联ByteArrayOutputStream
    ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
    // 3. 使用ObjectOutputStream的writeObject方法，读取要复制的对象
    objectOutputStream.writeObject(user1);
    // 4. 使用ByteArrayInputStream读取ByteArrayOutputStream的转化的对象字节数据
    ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
    // 5. 创建ObjectInputStream并用readObject读取对象字节数据返回新对象
    ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
    User user2 = (User) objectInputStream.readObject();

    System.out.println(user1 + ":" + user1.hashCode());
    System.out.println(user2 + ":" + user2.hashCode());
}

效果：

com.yynm.pojo.User@2b05039f:721748895
com.yynm.pojo.User@77468bd9:2001112025

4.3 使用IO改写Person的clone方法

4.3.1 开发步骤
  1. 克隆涉及的所有的类实现Serializable
  2. 修改Person类的clone方法，使用IO复制对象
  3. 测试演示
4.3.2 代码实现
  1. 克隆涉及的所有的类实现Serializable
  2. 修改Person类的clone方法，使用IO复制对象
package com.yynm.pojo;

import java.io.*;

/**
 * @Description: Person实体类
 * @Author: yeyulemon
 * @Date: 2021-12-16 21:06
 **/
public class Person implements Cloneable, Serializable {
    private String name;
    private Integer age;
    private Children children;
    private Grandson grandson;

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

    public Children getChildren() {
        return children;
    }

    public void setChildren(Children children) {
        this.children = children;
    }

    public Grandson getGrandson() {
        return grandson;
    }

    public void setGrandson(Grandson grandson) {
        this.grandson = grandson;
    }

    @Override
    public Person clone() throws CloneNotSupportedException {
        try {
            // 1. 创建ByteArrayOutputStream，将数据可以转换成字节
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            // 2. 创建ObjectOutputStream，关联ByteArrayOutputStream
            ObjectOutputStream oos = new ObjectOutputStream(baos);
            // 3. 使用ObjectOutputStream的writeObject方法，读取要复制的对象
            oos.writeObject(this);
            // 4. 使用ByteArrayInputStream读取ByteArrayOutputStream的转化的对象字节数据
            ByteArrayInputStream bAIS = new ByteArrayInputStream(baos.toByteArray());
            // 5. 创建ObjectInputStream并用readObject读取对象字节数据返回新对象
            ObjectInputStream oIS = new ObjectInputStream(bAIS);
            Person personClone = (Person) oIS.readObject();
            return personClone;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
}

测试：

@Test
public void test07() throws Exception {
    Person person1 = new Person();
    Person person2 = person1.clone();
    System.out.println(person1 + ":" + person1.hashCode());
    System.out.println(person2 + ":" + person2.hashCode());
}

效果：

com.yynm.pojo.Person@4dcbadb4:1305193908
com.yynm.pojo.Person@77468bd9:2001112025

5. 为什么使用clone方法需要实现Cloneable接口

答：源代码就是这么设定的，实现接口仅仅是一个可以使用clone方法的标记。
那么源代码在哪里设定的呢？
查看jdk源码我们发现：
Onject clone方法
因此，我们需要查看native修饰的背后的源码，这个一直要追溯到jdk底层C，C++源码。

5.1 下载完整jdk源码

下载地址：http://jdk.java.net/java-se-ri/7
查看步骤
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
源码展示：

JVM_ENTRY(jobject, JVM_Clone(JNIEnv* env, jobject handle))
  JVMWrapper("JVM_Clone");
  Handle obj(THREAD, JNIHandles::resolve_non_null(handle));
  const KlassHandle klass (THREAD, obj->klass());
  JvmtiVMObjectAllocEventCollector oam;

#ifdef ASSERT
  // Just checking that the cloneable flag is set correct
  if (obj->is_javaArray()) {
    guarantee(klass->is_cloneable(), "all arrays are cloneable");
  } else {
    guarantee(obj->is_instance(), "should be instanceOop");
    bool cloneable = klass->is_subtype_of(SystemDictionary::Cloneable_klass());
    guarantee(cloneable == klass->is_cloneable(), "incorrect cloneable flag");
  }
#endif

  // Check if class of obj supports the Cloneable interface.
  // All arrays are considered to be cloneable (See JLS 20.1.5)
  if (!klass->is_cloneable()) {
    ResourceMark rm(THREAD);
    THROW_MSG_0(vmSymbols::java_lang_CloneNotSupportedException(), klass->external_name());
  }

  // Make shallow object copy
  const int size = obj->size();
  oop new_obj = NULL;
  if (obj->is_javaArray()) {
    const int length = ((arrayOop)obj())->length();
    new_obj = CollectedHeap::array_allocate(klass, size, length, CHECK_NULL);
  } else {
    new_obj = CollectedHeap::obj_allocate(klass, size, CHECK_NULL);
  }
  // 4839641 (4840070): We must do an oop-atomic copy, because if another thread
  // is modifying a reference field in the clonee, a non-oop-atomic copy might
  // be suspended in the middle of copying the pointer and end up with parts
  // of two different pointers in the field.  Subsequent dereferences will crash.
  // 4846409: an oop-copy of objects with long or double fields or arrays of same
  // won't copy the longs/doubles atomically in 32-bit vm's, so we copy jlongs instead
  // of oops.  We know objects are aligned on a minimum of an jlong boundary.
  // The same is true of StubRoutines::object_copy and the various oop_copy
  // variants, and of the code generated by the inline_native_clone intrinsic.
  assert(MinObjAlignmentInBytes >= BytesPerLong, "objects misaligned");
  Copy::conjoint_jlongs_atomic((jlong*)obj(), (jlong*)new_obj,
                               (size_t)align_object_size(size) / HeapWordsPerLong);
  // Clear the header
  new_obj->init_mark();

  // Store check (mark entire object and let gc sort it out)
  BarrierSet* bs = Universe::heap()->barrier_set();
  assert(bs->has_write_region_opt(), "Barrier set does not have write_region");
  bs->write_region(MemRegion((HeapWord*)new_obj, size));

  // Caution: this involves a java upcall, so the clone should be
  // "gc-robust" by this stage.
  if (klass->has_finalizer()) {
    assert(obj->is_instance(), "should be instanceOop");
    new_obj = instanceKlass::register_finalizer(instanceOop(new_obj), CHECK_NULL);
  }

  return JNIHandles::make_local(env, oop(new_obj));
JVM_END

校验当前类是否实现克隆接口的代码：

// Check if class of obj supports the Cloneable interface.
// All arrays are considered to be cloneable (See JLS 20.1.5)
if (!klass->is_cloneable()) {
  ResourceMark rm(THREAD);
  THROW_MSG_0(vmSymbols::java_lang_CloneNotSupportedException(), klass->external_name());
}

注释翻译：

数组类型默认可以直接克隆，而其它对象实现clone需要先实现Cloneable接口，否则抛出：
CloneNotSupportedException异常

结论，对象使用clone方法必须实现Cloneable接口。

夜雨柠檬
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java object 之clone方法全面解析
09-02
Java中的`clone()`方法是Object类的一个成员方法，它提供了创建一个对象副本的功能。这篇文章将深入探讨`clone()`方法的工作原理、使用场景以及浅拷贝（shallow clone）与深拷贝（deep clone）的区别。 首先，让...
JAVA对象clone方法代码实例解析
08-19
JAVA对象clone方法代码实例解析 JAVA对象clone方法是JAVA编程语言中的一种复制对象的方法，通过实现Cloneable接口和重写clone方法，可以实现对象的浅复制或深复制。在本文中，我们将通过示例代码详细介绍JAVA对象...
Java基础--详解Object类中的clone方法
Wyong9802的博客
07-13 1823
clone()方法 clone()方法将对象复制了一份并返回给调用者。一般而言，clone()方法满足： 对任何对象a，都有a.clone() != a，即克隆对象与源对象不同 对任何对象a，都有a.clone().getClass == a.getClass，即克隆对象与源对象的类型相同 clone()方法时Object类的一个方法，因此，所有的类都具有这个方法。clone()的作用在于复...
java clone() 方法详解及深克隆与浅克隆
weixin_42361467的博客
05-12 1829
clone 翻译过来就是克隆，顾名思义就是创造一个一模一样的事物。Java 代码中 clone() 方法是 Object 方法，而 Object 又是所有类的父类，也就是说所有 java 对象都可以调用 clone 方法克隆一个和自己“相同”的对象。本篇博客我打算系统整理 java clone() 方法的原理以及深克隆和浅克隆的关系。
Java基础深度总结：Object类-clone方法
白日梦想家的博客
07-25 832
凡心所向，素履所往，生如逆旅，一苇以航。 内容1.clone概述2.Cloneable接口3.clone与new的区别4.浅拷贝与深拷贝5.Object.clone6.浅拷贝存在的问题 1.clone概述 clone() 是 Object 的 protected 方法，它不是 public，一个类不显式去重写 clone()，其它类就不能直接去调用该类实例的 clone() 方法。 protected native Object clone() throws CloneNotSupportedExcept
java实现简单的克隆（调用Object的clone方法和浅拷贝，深拷贝)
最新发布
m0_68402491的博客
05-15 1450
的clone方法是protected修饰需要在克隆类中重写2：编译时异常/受查异常3：向下转型时需要强制类型转换4：克隆类需要设置标记接口。
Java 中Object类clone方法
weixin_57219176的博客
04-04 943
/*Object类中的克隆方法： * protected Object clone()：创建并返回此对象的一个副本 * */ public class ObjectDemo { public static void main(String[] args) throws CloneNotSupportedException { //创建学生对象 Student s=new Student("张三",18); System.out.println(s.getAge()+"--"+s....
Java clone方法详解及简单实例
08-31
`clone`方法是Java `Object`类中的一个`protected`方法，这意味着在使用`clone`时，需要考虑以下几个关键点： 1. **什么是`clone`**： 当我们需要创建一个已有对象的精确副本时，就可以使用`clone`方法。它不是...
Java中clone方法共6页.pdf.zip
10-30
在Java编程语言中，`clone()`方法是一个非常重要的概念，特别是在对象复制和克隆方面。这个方法来源于`java.lang.Object`类，所有Java类都默认继承了这个方法。本资料"Java中clone方法共6页.pdf.zip"可能包含了关于...
java 中clone()的使用方法
08-29
Java 中 clone() 的使用方法 Java 中的 clone() 方法是对象的复制方法，其主要作用是创建一个与原对象相同的新对象。下面将详细介绍 Java 中 clone() 方法的使用方法。 什么是 clone() 方法？ clone() 方法是 ...
Java Object对象之clone方法
热门推荐
bigconvience的专栏
05-05 3万+
参考文章：点击打开链
java中clone方法_Java Object clone（）方法– Java中的克隆
从零开始的教程世界
07-22 1203
java使用clone方法Cloning is the process of creating a copy of an Object. Java Object class comes with native clone() method that returns the copy of the existing instance. 克隆是创建对象副本的过程。 Java Object类带有本机cl...
java Object类 clone()方法 详解
three__stones的博客
03-22 5837
今天写程序的时候像直接调用Object的clone()方法来copy一个副本，但是发现myEclipse的提示中并没有该方法，以为在jdk1.7中取消了该方法，然后我直接敲上clone()后： public class TestObject { public static void main(String[] args) { Student s = new Student(1, "小时")
java deepcloneobject,Java Object之clone()方法
weixin_42348371的博客
03-19 141
Object中的clone方法定义如下：protected native Object clone() throws CloneNotSupportedException;定义一个可克隆的对象，一般的步骤如下：implements Cloneable;override clone()Example//Person及其子类都有了克隆能力class Person implements Cloneabl...
java clone对象浅析
juezhu0193的博客
03-01 201
Cloneable的用途 Cloneable是标记型的接口，它们内部都没有方法和属性，实现 Cloneable来表示该对象能被克隆，能使用Object.clone()方法。如果没有实现 Cloneable的类对象调用clone()就会抛出CloneNotSupportedException。 克隆的分类 浅克隆（shallow clone），浅克隆是指拷贝对象时仅仅copy对象本身和对象中的基...
java.lang.Object.clone()解读
weixin_34037515的博客
10-07 213
java.lang.Object.clone()分析 　　 　　首先，看一下源码： 1 public class Object { 2 protected native Object clone() throws CloneNotSupportedException; 3 } 　　由源代码我们会发现： 　　第一：Object类的clone()方法是一个native方...
使用成员方法实现对象克隆
m0_61843855的博客
08-05 65
/对象调用成员方法并完成对象传参后将克隆得到的新对象 直接地址传递·//太麻烦 直接进行地址传递更方便 此文代码仅为训练类 成员方法作用。//直接地址传递也行。//定义成员方法 ：修饰符 返回值类型 方法名 （参数列表）//此处的对象克隆仅为成员变量克隆 可以实现成员方法的克隆。//在一个类中可以实例化另外一个类的对象。//解决问题的方法封装在类中。//要被克隆的对象所属的类。//要完成克隆方法所属的类。//此类主要使用成员变量。//此类主要使用成员方法。...
深拷贝和浅拷贝
zlj1217的博客
12-24 187
深拷贝与浅拷贝 对对象的深拷贝和浅拷贝我们并不陌生。 （1）浅拷贝： 在浅拷贝中，如果原型对象的成员变量是值类型，将复制一份给克隆对象；如果原型对象的成员变量是引用类型，则将引用对象的地址复制一份给克隆对象，也就是说原型对象和克隆对象的成员变量指向相同的内存地址。简单来说，在浅拷贝中，当对象被复制时只复制它本身和其他包含的值类型的成员变量，而引用类型的成员对象并没有复制。在Java中，通过覆盖O...
Java中Object类的clone()（克隆）方法
yuxxz的专栏
02-11 4744
Java提供了一个projected修饰的clone()方法，该方法用来实现对象的“自我克隆”，即得到当前对象的一个副本，并且两个对象之间完全隔离。需要注意的是，由于该方法使用projected修饰，因此该方法只能被子类重写或者调用。 自定义类实现克隆的步骤如下： 1、首先自定义类需要实现Cloneable接口，该接口只是一个标记性接口（接口中没有定义任何方法），表明实现该接口的类可以实现“自

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值