分析轮子（九）- Cloneable.java

注：玩的是JDK1.7版本

一：Cloneable.java 接口也是标记接口，所以，它没有任何方法和属性，实现此接口表示的意思是：可以调用 Object.java 类的 clone() 方法，进行简单的属性到属性之间的克隆，如果没有实现此接口的话调用 Object.java 类的 clone() 方法会抛出  java.lang.CloneNotSupportedException 异常。

另外，如果实现了 Cloneabel.java 接口，通常会复写 Object.java 的 clone() 方法，因为，在 Object.java 中 clone() 方法是受保护的，所以，需要提供一个public的 clone() 方法。

package java.lang;

/**
 * A class implements the <code>Cloneable</code> interface to
 * indicate to the {@link java.lang.Object#clone()} method that it
 * is legal for that method to make a
 * field-for-field copy of instances of that class.
 * <p>
 * Invoking Object's clone method on an instance that does not implement the
 * <code>Cloneable</code> interface results in the exception
 * <code>CloneNotSupportedException</code> being thrown.
 * <p>
 * By convention, classes that implement this interface should override
 * <tt>Object.clone</tt> (which is protected) with a public method.
 * See {@link java.lang.Object#clone()} for details on overriding this
 * method.
 * <p>
 * Note that this interface does <i>not</i> contain the <tt>clone</tt> method.
 * Therefore, it is not possible to clone an object merely by virtue of the
 * fact that it implements this interface.  Even if the clone method is invoked
 * reflectively, there is no guarantee that it will succeed.
 *
 * @author  unascribed
 * @see     java.lang.CloneNotSupportedException
 * @see     java.lang.Object#clone()
 * @since   JDK1.0
 */
public interface Cloneable {
}

二：验证上述结论

1）定义一个简单的类，特意不实现 Cloneabel.java 接口，如下所示：

/**
 * @description：人类
 * @author：godtrue
 * @create：2018-09-09
 */
public class Person{/** 请注意这里，没有实现 Cloneable 接口 **/
    /**
     * 身份证号
     */
    private int id;

    /**
     * 姓名
     */
    private String name;

    /**
     * 性别
     */
    private boolean sex;

    /**
     * 年龄
     */
    private int age;

    /**
    *
    *@description: 复写 Object.java 的克隆方法
    *@param
    *@return: java.lang.Object
    *@author: godtrue
    *@createTime: 2018-09-18
    *@version: v1.0
    */
    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    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 boolean isSex() {
        return sex;
    }

    public void setSex(boolean sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

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

    @Override
    public String toString() {
        final StringBuilder sb = new StringBuilder("Person{");
        sb.append("id=").append(id);
        sb.append(", name='").append(name).append('\'');
        sb.append(", sex=").append(sex==true?"男":"女");
        sb.append(", age=").append(age);
        sb.append('}');
        return sb.toString();
    }
}

2）定义一个测试入口类，如下所示：

/**
 * @description：玩一把Cloneable
 * @author：godtrue
 * @create：2018-09-18
 */
public class PlayCloneable {
    /**
    *
    *@description: 测试入口，主方法
    *@param args
    *@return: void
    *@author: godtrue
    *@createTime: 2018-09-18
    *@version: v1.0
    */
    public static void main(String[] args) throws CloneNotSupportedException{
        Person person = genPerson();
        System.out.println("person is "+person);

        Person personTemp = (Person) person.clone();
        personTemp.setId(618);
        personTemp.setName("六一八");
        System.out.println("personTemp is "+personTemp);
    }

    /**
    *
    *@description: 生成 Person 对象信息
    *@param
    *@return: com.godtrue.Person
    *@author: godtrue
    *@createTime: 2018-09-18
    *@version: v1.0
    */
    private static Person genPerson(){
        Person person = new Person();
        person.setId(1111);
        person.setSex(true);
        person.setName("双十一");
        person.setAge(2);
        return person;
    }
}

3）测试的结果如下所示（果然，抛出了对应的异常，侧面反映出我们的结论了：没实现Cloneable.java接口时，调用 Object.java 类的 clone() 方法会抛出 java.lang.CloneNotSupportedException 异常）：

4）调整 Person.java 类 使其实现 Cloneable.java 接口，然后再实验下，看看什么效果，调整的类如下所示：

/**
 * @description：人类
 * @author：godtrue
 * @create：2018-09-09
 */
public class Person implements Cloneable{/** 请注意这里，实现了 Cloneable 接口 **/
    /**
     * 身份证号
     */
    private int id;

    /**
     * 姓名
     */
    private String name;

    /**
     * 性别
     */
    private boolean sex;

    /**
     * 年龄
     */
    private int age;

    /**
    *
    *@description: 复写 Object.java 的克隆方法
    *@param
    *@return: java.lang.Object
    *@author: godtrue
    *@createTime: 2018-09-18
    *@version: v1.0
    */
    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    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 boolean isSex() {
        return sex;
    }

    public void setSex(boolean sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

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

    @Override
    public String toString() {
        final StringBuilder sb = new StringBuilder("Person{");
        sb.append("id=").append(id);
        sb.append(", name='").append(name).append('\'');
        sb.append(", sex=").append(sex==true?"男":"女");
        sb.append(", age=").append(age);
        sb.append('}');
        return sb.toString();
    }
}

5）运行结果如下所示（正面反映出了我们的结论：当实现Cloneable.java接口时，能够正常调用 Object.java 类的 clone() 方法）：

三：为什么会这样呢？

1）先看如下的变种例子，注意 clone() 方法的实现，如下所示

/**
 * @description：人类
 * @author：godtrue
 * @create：2018-09-09
 */
public class Person{/** 请注意这里，没有实现 Cloneable 接口 **/
    /**
     * 身份证号
     */
    private int id;

    /**
     * 姓名
     */
    private String name;

    /**
     * 性别
     */
    private boolean sex;

    /**
     * 年龄
     */
    private int age;

    /**
    *
    *@description: 复写 Object.java 的克隆方法
    *@param
    *@return: java.lang.Object
    *@author: godtrue
    *@createTime: 2018-09-18
    *@version: v1.0
    */
    @Override
    public Object clone(){
        Person copy = new Person();
        copy.id = this.id;
        copy.name = this.name;
        copy.sex = this.sex;
        copy.age = this.age;

        return copy;
    }

    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 boolean isSex() {
        return sex;
    }

    public void setSex(boolean sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

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

    @Override
    public String toString() {
        final StringBuilder sb = new StringBuilder("Person{");
        sb.append("id=").append(id);
        sb.append(", name='").append(name).append('\'');
        sb.append(", sex=").append(sex==true?"男":"女");
        sb.append(", age=").append(age);
        sb.append('}');
        return sb.toString();
    }
}

2）运行结果如下所示，注意，不用处理  java.lang.CloneNotSupportedException 因为，我们的 Person.java 的 clone() 方法没用使用 Object.java 的 clone() 方法

3）看一下 Object.java 的 clone() 方法，从注释中我们可以得出如下关键信息

3-1）Object.java 的 clone() 方法是一个 native 方法

3-2）通过 Object.java 的 clone() 方法获取的新对象是一个浅克隆的对象，打个比方：有点类似两个连体双胞胎的关系（这个回头再细说）

3-3）针对没有实现 Cloneable.java 接口的类，如果复写了 Object.java 类的 clone() 方法，且通过 Object.java 类的 clone() 方法实现了对象的浅克隆的话，在调用复写的 clone() 方法的时候，就会抛出 java.lang.CloneNotSupportedException 异常，因为，Object.java 类的 clone() 方法抛出了此异常，所以，对应的应该有捕获或者再抛出的措施才行，（Object.java 类的 clone() 方法的本地实现我还没看，猜测，他会先检查对应的类是否实现了Cloneabe.java接口，如果没有，则会抛出  java.lang.CloneNotSupportedException 异常，如果实现了，则会进行对对象的浅克隆操作）

3-4）复写 Object.java 的 clone() 方法，和是否实现 Cloneable.java 接口没有什么必然关系，复写的 clone() 方法的实现，可以有多种选择，但是一旦选择使用 Object.java 类的 clone() 方法来快速实现一个对象的浅克隆的话，就必须实现 Cloneable.java 接口，否则就会抛出  java.lang.CloneNotSupportedException 异常

3-5）至此，我们也清楚了，Cloneable.java 接口的核心作用在于，可通过 Object.java 类的 clone() 方法进行对象的快速浅克隆，具体实现步骤如下所示：

第一步：实现Cloneable.java接口

第二步：复写Object.java类的clone()方法，使方法到处可用(public的访问权限)，调用Object.java类的clone()方法快速的浅克隆对象

第三步：如果想进行深克隆，也可以在浅克隆的基础上再加工处理

    /**
     * Creates and returns a copy of this object.  The precise meaning
     * of "copy" may depend on the class of the object. The general
     * intent is that, for any object {@code x}, the expression:
     * <blockquote>
     * <pre>
     * x.clone() != x</pre></blockquote>
     * will be true, and that the expression:
     * <blockquote>
     * <pre>
     * x.clone().getClass() == x.getClass()</pre></blockquote>
     * will be {@code true}, but these are not absolute requirements.
     * While it is typically the case that:
     * <blockquote>
     * <pre>
     * x.clone().equals(x)</pre></blockquote>
     * will be {@code true}, this is not an absolute requirement.
     * <p>
     * By convention, the returned object should be obtained by calling
     * {@code super.clone}.  If a class and all of its superclasses (except
     * {@code Object}) obey this convention, it will be the case that
     * {@code x.clone().getClass() == x.getClass()}.
     * <p>
     * By convention, the object returned by this method should be independent
     * of this object (which is being cloned).  To achieve this independence,
     * it may be necessary to modify one or more fields of the object returned
     * by {@code super.clone} before returning it.  Typically, this means
     * copying any mutable objects that comprise the internal "deep structure"
     * of the object being cloned and replacing the references to these
     * objects with references to the copies.  If a class contains only
     * primitive fields or references to immutable objects, then it is usually
     * the case that no fields in the object returned by {@code super.clone}
     * need to be modified.
     * <p>
     * The method {@code clone} for class {@code Object} performs a
     * specific cloning operation. First, if the class of this object does
     * not implement the interface {@code Cloneable}, then a
     * {@code CloneNotSupportedException} is thrown. Note that all arrays
     * are considered to implement the interface {@code Cloneable} and that
     * the return type of the {@code clone} method of an array type {@code T[]}
     * is {@code T[]} where T is any reference or primitive type.
     * Otherwise, this method creates a new instance of the class of this
     * object and initializes all its fields with exactly the contents of
     * the corresponding fields of this object, as if by assignment; the
     * contents of the fields are not themselves cloned. Thus, this method
     * performs a "shallow copy" of this object, not a "deep copy" operation.
     * <p>
     * The class {@code Object} does not itself implement the interface
     * {@code Cloneable}, so calling the {@code clone} method on an object
     * whose class is {@code Object} will result in throwing an
     * exception at run time.
     *
     * @return     a clone of this instance.
     * @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.
     * @see java.lang.Cloneable
     */
    protected native Object clone() throws CloneNotSupportedException;

4）看一下 java.lang.CloneNotSupportedException.java 的存在本意，不实现 Cloneable.java 接口，但是调用了 Object.java 类的 clone() 方法就会抛出此异常了

/**
 * Thrown to indicate that the <code>clone</code> method in class
 * <code>Object</code> has been called to clone an object, but that
 * the object's class does not implement the <code>Cloneable</code>
 * interface.
 * <p>
 * Applications that override the <code>clone</code> method can also
 * throw this exception to indicate that an object could not or
 * should not be cloned.
 *
 * @author  unascribed
 * @see     java.lang.Cloneable
 * @see     java.lang.Object#clone()
 * @since   JDK1.0
 */

public
class CloneNotSupportedException extends Exception {
    private static final long serialVersionUID = 5195511250079656443L;

    /**
     * Constructs a <code>CloneNotSupportedException</code> with no
     * detail message.
     */
    public CloneNotSupportedException() {
        super();
    }

    /**
     * Constructs a <code>CloneNotSupportedException</code> with the
     * specified detail message.
     *
     * @param   s   the detail message.
     */
    public CloneNotSupportedException(String s) {
        super(s);
    }
}