EffectiveJava（11）Java中的clone

java中的clone

clone构造器及其静态工厂的变形

优点:它们不依赖于某一种很有风险的,语言之外的对象创建机制;

它们不要求遵守尚未制定好文档的规范

他们不会于final域的正常使用发生冲突

它们不会抛出不必要的受检异常

它们不需要进行类型转换

/**

* 1.必须继承Cloneable接口

* 2.必须重写Object类中的clone()方法 –

* Cloneable接口改变了接口的通用规范,它改变了超类中受保护的方法的行为

* –无需构造器就可以创建对象

* a.clone对象分配有独立的内存地址 – x.clone()!=x;

* b.原始的克隆对象应该具有相同类型 x.clone().getClass == x.getClass 非必需

* c.原始的克隆对象调用equals方法的话,应该是相等的 非必需

* @author JacXuan

*

*/

public class Father implements Cloneable{
    private int age;
    private String name;
    private Son son;

    public Father(int age,String name,Son son){
        this.age = age;
        this.name = name;
        this.son = son;
    }

    public Son getSon(){
        return this.son;
    }
    public void setSon(Son son){
        this.son = son;
    }
    /**
     * 浅拷贝代码--
     * 原始对象和克隆对象拥有指向同一对象的两个引用,所以可以通过改变cloneFather
     * 中的Son来改变father中的Son对象
     * @throws CloneNotSupportedException
     */
//  @Override
//  public Object clone() throws CloneNotSupportedException{
//      return super.clone();
//  }   

    /**
     * 深拷贝 -- 在Son中实现clone方法  return super.clone();
     */
    @Override
    public Object clone() throws CloneNotSupportedException{
        Father father = (Father)super.clone();
        father.setSon((Son)father.getSon().clone());
        return father;
    }
}

    Son son  = new Son(20, "PG");
        Father father = new Father(40, "JacX", son);

            Father cloneFather = (Father)father.clone();
            System.out.println(father!=cloneFather);
            System.out.println(cloneFather.getClass() == father.getClass());
            System.out.println(cloneFather.equals(father));

2.package com.object.equals.clone.conctr;

/**
 * 拷贝构造函数 -- 一种特殊的构造器
 * 它将自己的类类型作为参数  传递一个类的实例给拷贝构造函数,
 * 然后他将返回一个新的类实例
 * @author JacXuan
 *
 */
public class CloneConctr {
    private Integer x;
    private  Integer y;

    public CloneConctr(CloneConctr cloneConctr){
        this.x = cloneConctr.x;
        this.y=cloneConctr.y;
    }

//  public CloneConctr copyPoint(CloneConctr cloneConctr) throws CloneNotSupportedException{
//      if(!(cloneConctr instanceof Cloneable)){
//          throw new CloneNotSupportedException("Invalid clone");
//      }
//
//      //可以做多种其他事情
//      return new CloneConctr(cloneConctr.x,cloneConctr.y);
//  }

/**
 * 最佳实践
 *1)当你不知道你是否可以调用clone()方法的类你不确定如果是在这个类中实现,
 *您可以检查和检查如果类的实例“可克隆”界面如下。
 */
    //  if(obj instanceof Cloneable){
    //obj2 = obj.clone();
    //}
    //Dont do this. Cloneabe dont have any methods
    //obj2 = obj.clone();
}

package com.object.equals.clone.conctr;

/**
 * 如果要继承它的话,则需要复制子类的参数并传递参数给父类的构造器
 * @author JacXuan
 *
 */
public class CloneConctr2 extends CloneConctr{
    private Integer z;

    public CloneConctr2(CloneConctr2 cloneConctr2){
        super(cloneConctr2);
        this.z = cloneConctr2.z;
    }
}

3.package com.object.equals.clone.hashtable;

/**
 * 解决克隆对象和原有对象引用链表相同引起的数据篡改 单独地拷贝并组成每个桶的链表
 * 如果链表比较长,容易导致栈溢出
 * @author JacXuan
 *
 */
public class HashTable implements Cloneable {
    private Entry[] buckets = null;

    private static class Entry {
        final Object key;
        Object value;
        Entry next;

        Entry(Object key, Object value, Entry next) {
            this.key = key;
            this.value = value;
            this.next = next;
        }

        Entry deepCopy() {
            //深度克隆  如果桶是空的,则clone下一个
            return new Entry(key, value, next == null ? null : next.deepCopy());
        }
    }

    @Override
    public HashTable clone() throws CloneNotSupportedException {
        HashTable result = (HashTable) super.clone();
        result.buckets = new Entry[buckets.length];
        for (int i = 0; i < buckets.length; i++) {
            if (buckets[i] != null) {
                result.buckets[i] = buckets[i].deepCopy();
            }
        }
        return result;
    }

}