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;

通过源代码可以发现几点：

1.clone方法是native方法，native方法的效率远高于非native方法，因此还是使用clone方法去做对象的拷贝而不是使用new的方法，copy。

2.此方法被protected修饰。这就意味着想要使用，必须继承它（废话，默认都是继承的）。然后重载它，如果想要使得其他类能使用这个类，需要设置成public。

3.返回值是一个Object对象，所以要强制转换才行。

测试clone方法，代码如下，

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