Object类的clone方法

最新推荐文章于 2024-04-26 14:34:07 发布
最新推荐文章于 2024-04-26 14:34:07 发布
阅读量4.7k 收藏 16
点赞数 11
分类专栏： java 文章标签： Object类的clone方法

Object类的clone方法

Object是所有类的基类，当你没有显示extends一个父类时，编译期会自动为你加上一个Object类。
在这里插入图片描述

  1. 这是一个native方法，说明这个方法的实现不是在java中，而是由C/C++实现，并编译成.dll文件，由java调用。registerNatives主要是将C/C++的方法映射到java中的native方法，实现方法命名的解耦。了解即可，知道是注册，细节暂时不研究。
private static native void registerNatives();
    static {
        registerNatives();
    }
  1. 第二点来关注 clone方法。
    protected native Object clone() throws CloneNotSupportedException;
    通过源代码可以发现几点：
    clone方法是native方法，native方法的效率远高于非native方法，因此还是使用clone方法去做对象的拷贝而不是使用new的方法，copy。
    此方法被protected修饰。这就意味着想要使用，必须继承它（废话，默认都是继承的）。然后重载它，如果想要使得其他类能使用这个类，需要设置成public。
    返回值是一个Object对象，所以要强制转换才行。
public class TestReen{
	
	public static void main(String[] args) throws Exception{
		
		TestReen tReen = new TestReen();
		
		TestReen copy = (TestReen)tReen.clone();
	}
	
}

但是运行时，发现抛异常了。

Exception in thread "main" java.lang.CloneNotSupportedException: com.test.count.TestReen
	at java.lang.Object.clone(Native Method)
	at com.test.count.TestReen.main(TestReen.java:11)

进入clone方法，看注释发现如下信息：表明此类不支持Cloneable接口的话就会报错。

@exception  CloneNotSupportedException  if the object's class does not
     *               support the {@code Cloneable} interface. Subclasses
     *               that override the {@code clone} method can also
     *               throw this exception to indicate that an instance cannot
     *               be cloned.

去看看Cloneable接口，空的，

public interface Cloneable {
}

总结其注释的话，差不多三点：
（1）此类实现了Cloneable接口，以指示Object的clone()方法可以合法地对该类实例进行按字段复制；
（2）如果在没有实现Cloneable接口的实例上调用Object的clone()方法，则会导致抛出CloneNotSupporteddException；
（3）按照惯例，实现此接口的类应该使用公共方法重写Object的clone()方法，Object的clone()方法是一个受保护的方法；
因此想实现clone的话，除了继承Object类外，还需要实现Cloneable接口;
创建并返回此对象的一个副本。对于任何对象x，表达式：
（1）x.clone() != x为true
（2）x.clone().getClass() == x.getClass()为true
（3）x.clone().equals(x)一般情况下为true，但这并不是必须要满足的要求

public class TestReen implements Cloneable{
	
	private int id;
	
	private static int i = 1;
	
	public TestReen() {
		System.out.println("i = " + i);
		System.out.println("执行了构造函数"+i);
		i++;
	}
 
	public int getId() {
		return id;
	}
 
	public void setId(int id) {
		this.id = id;
	}
 
	public static void main(String[] args) throws Exception{
		
		TestReen t1 = new TestReen();
		t1.setId(1);
		
		TestReen t2 = (TestReen)t1.clone();
		
		TestReen t3 = new TestReen();
		
		System.out.println("t1 id: "+ t1.getId());
		System.out.println("t2 id: "+ t2.getId());
		System.out.println("t1 == t2 ? " + (t1 == t2));
		System.out.println("t1Class == t2Class ? " + (t1.getClass() == t2.getClass()));
		System.out.println("t1.equals(t2) ? " + t1.equals(t2));
		
	}
}

结果如下，有几个发现：

  1. 构造函数除了new执行以外，clone并没有调用到构造函数，也就是clone方法是不走构造方法的。

  2. t1 和 t2 是不等的，说明指向了不同的堆地址空间，是两个对象。

  3. getClass是相同的，getClass是什么？是获取这个实例的类型类，有点拗口，其实就是TestReen类型，可见clone出来的类型还是一样的。

i = 1
执行了构造函数1
i = 2
执行了构造函数2
t1 id: 1
t2 id: 1
t1 == t2 ? false
t1Class == t2Class ? true
t1.equals(t2) ? false

国际惯例所有博客都会去关注的一点，浅克隆（shallow clone）和 深克隆（deep clone）。
浅克隆：Object的clone提供的就是浅克隆，由下面的例子可以看见，只克隆了自身对象和对象内实例变量的地址引用，它内部的实例变量还是指向原先的堆内存区域。

深克隆：克隆所有的对象，包括自身以及自身内部对象。
浅克隆测试代码：
TestReen中有一个实例变量SonReen。

public class TestReen implements Cloneable{
	private int id;
	private String name;
	private SonReen sonReen;
	public TestReen(int id, String name, SonReen sonReen) {
		this.id = id;
		this.name = name;
		this.sonReen = sonReen;
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public SonReen getSonReen() {
		return sonReen;
	}
	public void setSonReen(SonReen sonReen) {
		this.sonReen = sonReen;
	}
	public static void main(String[] args) throws Exception{
		
		SonReen sonReen = new SonReen(1, "张三");
		TestReen t1 = new TestReen(1, "李四", sonReen);
		TestReen t3 = new TestReen(2, "李四1", sonReen);
		TestReen t4 = new TestReen(3, "李四", sonReen);
		TestReen t2 = (TestReen)t1.clone(); 
		System.out.println("t1 ? "+ (t1 == t2));
		System.out.println("sonReen: ? "+ (t1.getSonReen() == t2.getSonReen()));
		System.out.println("t1.name == t3.name: ? " + (t1.getName() == t3.getName()));
		System.out.println("t1.name == t4.name: ? " + (t1.getName() == t4.getName()));
		System.out.println("T name: ? " + (t1.getName() == t2.getName()));
		System.out.println("S name: ? " + (t1.getSonReen().getSonName() == t2.getSonReen().getSonName()));
	}
}
class SonReen{
	private int sonId;
	private String sonName;
	public SonReen(int sonId, String sonName) {
		super();
		this.sonId = sonId;
		this.sonName = sonName;
	}
	public int getSonId() {
		return sonId;
	}
	public void setSonId(int sonId) {
		this.sonId = sonId;
	}
	public String getSonName() {
		return sonName;
	}
	public void setSonName(String sonName) {
		this.sonName = sonName;
	}
}

得到的结果如下：可以发现几点：

首先TestReen 不是同一个对象，但是它内部的实例变量sonReen 确实同一个对象。内部的String变量的行为和new出来的t1和t4行为一致，也是相等的。

t1 ? false
sonReen: ? true
t1.name == t3.name: ? false
t1.name == t4.name: ? true
T name: ? true
S name: ? true

深克隆：方法有两种：
1.先对对象进行序列化操作，然后立马反序列化出。

2.先调用super.clone()方法克隆出一个新对象来，然后在子类的clone()方法中手动给克隆出来的非基本数据类型（引用类型）赋值。（这个是网上别人的观点，稍后会去研究各个集合内的克隆原理，也是一个知识点）

序列化例子：

public class TestReen implements Cloneable,Serializable{
	private int id;
	private String name;
	private SonReen sonReen;
	public TestReen(int id, String name, SonReen sonReen) {
		this.id = id;
		this.name = name;
		this.sonReen = sonReen;
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public SonReen getSonReen() {
		return sonReen;
	}
	public void setSonReen(SonReen sonReen) {
		this.sonReen = sonReen;
	}
	public Object deepClone() throws Exception{
		
		ByteArrayOutputStream bo = new ByteArrayOutputStream();
		ObjectOutputStream out = new ObjectOutputStream(bo);
		out.writeObject(this);
		
		ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray());
		ObjectInputStream oi = new ObjectInputStream(bi);
		return oi.readObject();
		
	}
	public static void main(String[] args) throws Exception{
		
		SonReen sonReen = new SonReen(1, "张三");
		TestReen t1 = new TestReen(1, "李四", sonReen);
		TestReen t2 = (TestReen)t1.deepClone(); 
		System.out.println("t1 ? "+ (t1 == t2));
		System.out.println("sonReen: ? "+ (t1.getSonReen() == t2.getSonReen()));
		System.out.println("T name: ? " + (t1.getName() == t2.getName()));
		System.out.println("S name: ? " + (t1.getSonReen().getSonName() == t2.getSonReen().getSonName()));
		
		SonReen sonReen1 = new SonReen(1, "王五");
		t2.setSonReen(sonReen1);
		System.out.println("son : "+ t1.getSonReen().getSonName());
		System.out.println("son1 : "+ t2.getSonReen().getSonName());
		System.out.println("son == son1 : ? "+ (t1.getSonReen() ==  t2.getSonReen()));
		
	}
}
class SonReen implements Serializable{
	private int sonId;
	private String sonName;
	public SonReen(int sonId, String sonName) {
		super();
		this.sonId = sonId;
		this.sonName = sonName;
	}
	public int getSonId() {
		return sonId;
	}
	public void setSonId(int sonId) {
		this.sonId = sonId;
	}
	public String getSonName() {
		return sonName;
	}
	public void setSonName(String sonName) {
		this.sonName = sonName;
	}
}

如下结果： 发现t1 和 t2 内的sonReen比较时 已经是false了，说明克隆的同时将对象内部的实例对象也跟着一起复制了，并且下面对 t2 内部son 的名字改变也没有影响 t1的值。

t1 ? false
sonReen: ? false
T name: ? false
S name: ? false
son : 张三
son1 : 王五
son == son1 : ? false

》》》博主长期更新学习心得，推荐点赞关注！！！
》》》若有错误之处，请在评论区留言，谢谢！！！

世界，你好
关注
  • 11
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java object 之clone方法全面解析
09-02
Java中的`clone()`方法是Object类的一个成员方法，它提供了创建一个对象副本的功能。这篇文章将深入探讨`clone()`方法的工作原理、使用场景以及浅拷贝（shallow clone）与深拷贝（deep clone）的区别。 首先，让...
Object源码分析（一）-- clone方法
lwgzj的博客
09-05 4676
java基类Object 在你编写一个类的时候，若无指定父类（没有显式extends一个父类）编译器（一般编译器完成该步骤）会默认的添加Object为该类的父类（可以将该类反编译看其字节码，不过貌似Java7自带的反编译javap现在看不到了）。  　　再说的详细点：假如类A，没有显式继承其他类，编译器会默认添加Object为其父类；若有，那么那个显式父类呢？要么是没有显式继承，那么Objec
object方法_日常-Object的Clone方法分析
weixin_39723678的博客
11-27 124
创建对象的三种方式: 使用new创建对象 [将地址值存储到堆中,会出现OOM] 使用反射的方式创建对象 [不安全] 使用Object类中自带的clone方法如何使用clone呢?第一步在对象类中实现Cloneable接口 [标识符]第二步在对象类中重写clone方法第三步创建对象调用clone方法浅拷贝 [Java中默认的就是浅拷贝]clone出来的对象不一样,...
hutool 工具包 深克隆踩坑
最新发布
DS_Watson的博客
04-26 526
java 深克隆
（基础系列）object clone 的用法、原理和用途
weixin_33976072的博客
09-18 541
前言 object clone（对象克隆）网上资料很多，那我为什么还要写下这篇文章呢？主要是想汇聚多篇文章的优秀之处以及我对于对象克隆的理解来加深印象，也使读者能更全面的理解对象克隆的用法、原理和用途。 一、何谓 “object clone” 顾名思义clone就是一个相同东西的副本,是一个具体存在的复制体，是一个从生物科学开始变得熟悉的术语。在计算机行业，该术语被广泛用于指Compaq，戴尔等...
Object克隆方法解析
逝去的往事的博客
07-11 1245
克隆方法的由来 问题一：什么是克隆（clone）方法 答： 创建并返回此对象的一个副本——按照原对象，创建一个新的对象（复制原对象的内容）。 问题二：已经存在new关键字和反射技术都可以创建对象，为什么还需要一个Object的clone方法呢？ 答：必然是new关键字和反射技术，存在一些弊端。 new关键字和反射创建对象的弊端： 通过new和反射可以创建内容一模一样的对象。但是，创建对象之后，通过...
Java基础--详解Object类中的clone方法
Wyong9802的博客
07-13 1811
clone()方法 clone()方法将对象复制了一份并返回给调用者。一般而言，clone()方法满足： 对任何对象a，都有a.clone() != a，即克隆对象与源对象不同 对任何对象a，都有a.clone().getClass == a.getClass，即克隆对象与源对象的类型相同 clone()方法时Object类的一个方法，因此，所有的类都具有这个方法。clone()的作用在于复...
深入理解JavaScript中的对象复制(Object Clone)
10-22
下面小编就为大家带来一篇深入理解JavaScript中的对象复制(Object Clone)。小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
java基础之Object类
09-03
Object类位于`java.lang`包中，提供了许多基础方法，使得子类能够进行基本的比较、转换和表示。 1. `equals()`方法： `equals()`方法用于比较两个对象是否相等。默认情况下，`equals()`方法与`==`运算符的行为类似...
object-clone-proposal:关于ECMAScript中的Object.clone方法的建议
05-26
Object.clone（）地位冠军：待定作者：亚历克斯·洛尔舞台：0-稻草人动机使用散布运算符... ，可以很容易地对对象进行浅表克隆。 在某些情况下，需要创建对象的深层克隆。 本地复制引用的内存比手动克隆要有效得多。...
JAVA对象clone方法代码实例解析
08-19
然后，我们定义了一个Girl类，该类继承自Person类，并重写了clone方法。在clone方法中，我们首先调用了super.clone()方法，这将创建一个新的Girl对象，然后我们将新的对象的cup属性设置为当前对象的cup属性值。 ...
java.lang.Object.clone()
小黄人
09-16 902
首先，看一下源码： 1 public class Object { 2 protected native Object clone() throws CloneNotSupportedException; 3 } 　　由源代码我们会发现： 　　第一：Object类的clone()方法是一个native方法，native方法的效率一般来说都是远高于Java中的非nat
Object类中的clone()方法
2301_80636143的博客
03-21 1242
1要在类中实现Cloneable接口（异常的知识）2重写clone()方法，把throws CloneNotSupportedException放在main方法后面（异常的知识可以先后续学了在了解）3.强制类型转换成要克隆的对象的类型（因为clone返回Object类型）4.克隆方法是浅拷贝（接下来介绍）
常用类之Object类Clone方法
qq_52616731的博客
07-23 844
Object 这个类提供的 clone 方法用于实现对象的复制，复制的对象需要两个准备工作： 1、要 clone 的类实现标识接口 Cloneable，表示该对象可以支持复制操作。 2、将从父类中继承的 clone 方法暴漏出来，因为 clone 方法在 Object 类中是 protected 修饰的。 克隆分为浅克隆和深克隆 浅克隆： 原对象与克隆对象指向同一个地址 深克隆： 将原对象原地址一起克隆，从而出现一个新的对象 演示代码： public class CloneRevie
怎样理解 Object 类中的 clone() 方法？
m0_70325779的博客
09-08 191
所以就有一个问题，我们的代码肯定不能在 java.lang 包下编写，而我们的业务类通常为了能够调用 clone() 去继承实体类，因为可能需要继承其他类，两种办法都行不通，所以我们不许重写父类 Object 中的 clone() 方法，扩大访问权限，才能够调用。基本数据类型是在各自的JVM栈中存储，而引用数据类型则是在堆中存储，JVM栈中的对象保存的不过是堆中对象的内存地址。而且默认重写方法采用的是浅拷贝，如果被克隆对象中含有引用数据类型，只会复制其对象的内存地址，和被克隆的对象操作同一引用数据类型。
Java基础深度总结：Object类-clone方法
白日梦想家的博客
07-25 819
凡心所向，素履所往，生如逆旅，一苇以航。 内容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()方法详解
ahrtolia的博客
07-10 1018
1、clone()方法概述 最近在学习《码出高效》这本书的时候关于Object中的clone()方法书中提及对象clone方法是浅拷贝，如果想使用深拷贝需要覆写clone()方法实现域对象的深度遍历式拷贝，于是我就总结了一些关于clone方法的问题。 注意：方法native表明实现方法的程序设计语言不是Java。clone方法前使用native关键字约束表示需要使用本地计算机语言或C语言访问硬件，这些方法标记为native。 native方法可以是终极的、公用的、 私有的、保护的、重载的或者覆盖的。 cl
浅聊Object中的clone()方法
m0_59841734的博客
08-30 439
深克隆？有多深啊？
通过object类的clone方法 需要实现Cloneable接口，重写object类的clone方法。
05-26
2. 在被复制的类中，必须重写`Object`类中的`clone()`方法，并且将方法的访问权限设置为`public`。 重写`clone()`方法时，需要注意以下几点： 1. 深拷贝和浅拷贝的问题，需要根据实际情况进行选择； 2. 在重写`...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值