Object类的clone方法

Object是所有类的基类，当你没有显示extends一个父类时，编译期会自动为你加上一个Object类。

1. 这是一个native方法，说明这个方法的实现不是在java中，而是由C/C++实现，并编译成.dll文件，由java调用。registerNatives主要是将C/C++的方法映射到java中的native方法，实现方法命名的解耦。了解即可，知道是注册，细节暂时不研究。

private static native void registerNatives();
    static {
        registerNatives();
    }

2. 第二点来关注 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

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

基本描述：

　　(1)Object类位于java.lang包中，java.lang包包含着Java最基础和核心的类，在编译时会自动导入；

　　(2)Object类是所有Java类的祖先。每个类都使用 Object 作为超类。所有对象（包括数组）都实现这个类的方法。可以使用类型为Object的变量指向任意类型的对象

Object的主要方法介绍：

hashCode()方法：

hash值：Java中的hashCode方法就是根据一定的规则将与对象相关的信息（比如对象的存储地址，对象的字段等）映射成一个数值，这个数值称作为散列值。

情景：考虑一种情况，当向集合中插入对象时，如何判别在集合中是否已经存在该对象了？（注意：集合中不允许重复的元素存在）。

大多数人都会想到调用equals方法来逐个进行比较，这个方法确实可行。但是如果集合中已经存在一万条数据或者更多的数据，如果采用equals方法去逐一比较，效率必然是一个问题。此时hashCode方法的作用就体现出来了，当集合要添加新的对象时，先调用这个对象的hashCode方法，得到对应的hashcode值。实际上在HashMap的具体实现中会用一个table保存已经存进去的对象的hashcode值，如果table中没有该hashcode值，它就可以直接存进去，不用再进行任何比较了；如果存在该hashcode值， 就调用它的equals方法与新元素进行比较，相同的话就不存了，不相同就散列其它的地址。

重写hashCode（）方法的基本规则：

· 在程序运行过程中，同一个对象多次调用hashCode（）方法应该返回相同的值。

· 当两个对象通过equals（）方法比较返回true时，则两个对象的hashCode（）方法返回相等的值。

· 对象用作equals（）方法比较标准的Field，都应该用来计算hashCode值。

Object本地实现的hashCode()方法计算的值是底层代码的实现，采用多种计算参数，返回的并不一定是对象的（虚拟）内存地址，具体取决于运行时库和JVM的具体实现。

equals()方法：比较两个对象是否相等

我们知道所有的对象都拥有标识(内存地址)和状态(数据)，同时“==”比较两个对象的的内存地址，所以说使用Object的equals()方法是比较两个对象的内存地址是否相等，即若object1.equals(object2)为true，则表示equals1和equals2实际上是引用同一个对象。虽然有时候Object的equals()方法可以满足我们一些基本的要求，但是我们必须要清楚我们很大部分时间都是进行两个对象的比较，这个时候Object的equals()方法就不可以了，实际上JDK中，String、Math等封装类都对equals()方法进行了重写。

 clone()方法：快速创建一个已有对象的副本

第一：Object类的clone()方法是一个native方法，native方法的效率一般来说都是远高于Java中的非native方法。这也解释了为什么要用Object中clone()方法而不是先new一个类，然后把原始对象中的信息复制到新对象中，虽然这也实现了clone功能。

第二：Object类中的 clone()方法被protected修饰符修饰。这也意味着如果要应用 clone()方 法，必须继承Object类。

第三：Object.clone()方法返回一个Object对象。我们必须进行强制类型转换才能得到我们需要的类型。

克隆的步骤：1：创建一个对象；   2：将原有对象的数据导入到新创建的数据中。

clone方法首先会判对象是否实现了Cloneable接口，若无则抛出CloneNotSupportedException, 最后会调用internalClone. intervalClone是一个native方法，一般来说native方法的执行效率高于非native方法。

复制对象 or 复制引用

可已看出，打印的地址值是相同的，既然地址都是相同的，那么肯定是同一个对象。p和p1只是引用而已，他们都指向了一个相同的对象Person(23, "zhang") 。 可以把这种现象叫做引用的复制。

从打印结果可以看出，两个对象的地址是不同的，也就是说创建了新的对象， 而不是把原对象的地址赋给了一个新的引用变量：

深拷贝 or 浅拷贝

由于age是基本数据类型， 那么对它的拷贝没有什么疑议，直接将一个4字节的整数值拷贝过来就行。但是name是String类型的， 它只是一个引用， 指向一个真正的String对象，那么对它的拷贝有两种方式： 直接将源对象中的name的引用值拷贝给新对象的name字段， 或者是根据原Person对象中的name指向的字符串对象创建一个新的相同的字符串对象，将这个新字符串对象的引用赋给新拷贝的Person对象的name字段。这两种拷贝方式分别叫做浅拷贝和深拷贝。

通过下面代码进行验证。如果两个Person对象的name的地址值相同， 说明两个对象的name都指向同一个String对象， 也就是浅拷贝， 而如果两个对象的name的地址值不同， 那么就说明指向不同的String对象， 也就是在拷贝Person对象的时候， 同时拷贝了name引用的String对象， 也就是深拷贝。

对于对象的浅拷贝和深拷贝还有更深的细节，可以参考：详解Java中的clone方法 -- 原型模式

toString()方法：toString 方法会返回一个“以文本方式表示”此对象的字符串。结果应是一个简明但易于读懂的信息表达式。建议所有子类都重写此方法。

 Object 类的 toString 方法返回一个字符串，该字符串由类名（对象是该类的一个实例）、at 标记符“@”和此对象哈希码的无符号十六进制表示组成。

finalize()方法：垃圾回收器准备释放内存的时候，会先调用finalize()。

　　(1).  对象不一定会被回收。

       (2).垃圾回收不是析构函数。

       (3).垃圾回收只与内存有关。

       (4).垃圾回收和finalize()都是靠不住的，只要JVM还没有快到耗尽内存的地步，它是不会浪费时间进行垃圾回收的。

转自 https://www.cnblogs.com/myseries/p/7435395.html

Object类九大方法之equals方法

所有类都从Object类中继承了equals方法,Object类中的equals方法的源代码如下:

public boolean equals(Object obj){
    return this=obj;
}

Object中的equals方法是判断this和obj本省的值是否相等,即用来判断调用equals的对象和形参obj所引用的对象是否为同一个对象,所谓的同一个对象就是指内存中同一块储存的单元(地址值)如果this和obj指向的是同一块内存对象,则返回ture,如果this和obj指向的不是同一块内存,则返回false.

需要注意的是:即便是内容方完全相同的两块不同的内存对象,也返回false.因为比较的是地址值.

那么equals()方法与之前的’=="有什么区别呢?

首先了解一下java内存的只要划分

堆:存放的是New出来的对象,此对象由垃圾收集器收集,垃圾集器针对的就是堆区.

栈:每调用一个方法,会创建一个栈帧,存放局部变量.

方法区:类的所有信息,包括所有的方法,静态变量,常量.

通过下面的代码我们加深一下equals和=的区别:

public class Equals{
    public static void main(String[]args){
        String s1="apple";
        String s2="apple";
        System.out.print(s1==s2)//true,比较的是对象的地址值,因为两个对象都存在常量池中所以为true
        System.out.print(s1.equals(s2))//true,因为此Equals是Object的方法比较的是内容所以为true
        String s3=new String("apple");
        String s4=new String("apple");
        System.out.print(s3==s4);//false,地址值不一样
        System.out.print(s3.equals(s4));//true,因为此Equals是Object的方法比较的是内容所以为true
    }
}

结论:

"== "比较的是变量(栈)内存中存放的对象的内存地址，用来判断两个对象的地址是否相同，即是否是指相同一个对象

“equals”:不能做基本类型的比较,引用类型如果不重写比较的是地址值,重写之后比较的是内容.

从内存的划分我们来理解这个区别

String s1=new String("apple");
String s2=new String("apple"); 
System.out.println(s1==s2);  //false 
System.out.println(s1.equals(s2));  //true  

因为“”比较的是两个引用的对象是否相等，从上图很容易看出来不等，所以System.out.println(s1s2)，结果为False；而equals()方法比较的是两个对象的实际内容，从图中可以看出s1和s2都指向apple，内容是相同的，所以System.out.println(s1.equals(s2))，结果为True。

String s1="apple";
String s2="apple";
System.out.println(s1==s2);//true
System.out.println(s1.equals(s2));//true