设计模式--原型模式

/**
 *     原型模式
 * */
public class clone {
    public static void main(String[] args) {
        /** 创建大对象 */
        BigObject bigObject = new BigObject();
        bigObject.field1 = 111;
        bigObject.field2 = 111.11;
        bigObject.field3 = "最外层大对象";
        bigObject.field4 = false;
        bigObject.innerClass1 = new InnerClass1(222,222.22,"第二层innerClass1",true,new InnerClass3(333,333.33,"第三层innerClass1",true));
        bigObject.innerClass2 = new InnerClass2(444,444.44,"第二层innerClass2",false);
        /** 克隆大对象 */
        BigObject newObject = bigObject.clone();
        /** 输出比较一下 */
        
        System.err.println(bigObject.getClass().getName() + "@" + Integer.toHexString(bigObject.hashCode()));
        System.err.println(bigObject);
        System.err.println("");
        System.err.println(newObject.getClass().getName() + "@" + Integer.toHexString(newObject.hashCode()));
        System.err.println(newObject);
    }
}

/**
 *     大对象，需要实现Cloneable这个空接口，这是原型模式的关键
 * */
class BigObject implements Cloneable{
    int field1;
    Double field2;
    String field3;
    boolean field4;
    InnerClass1 innerClass1;
    InnerClass2 innerClass2;
    
    public BigObject(int field1, Double field2, String field3, boolean field4, InnerClass1 innerClass1,
            InnerClass2 innerClass2) {
        this.field1 = field1;
        this.field2 = field2;
        this.field3 = field3;
        this.field4 = field4;
        this.innerClass1 = innerClass1;
        this.innerClass2 = innerClass2;
        imitateDelay();
    }
    public BigObject() {
        imitateDelay();
    }
    /**
     *     模拟延迟
     * */
    @SuppressWarnings("static-access")
    private void imitateDelay() {
        try {
            // 模拟创建这个对象需要花费2秒
            Thread.currentThread().sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    /**
     *     重写克隆方法，这是原型模式的关键
     * */
    @Override
    public BigObject clone() {
        BigObject newObject = null;
        try {
            /** 
             *     这里一定要调用父类的构造方法，决不能调用自己子类的构造方法，不然会死循环的
             *     super.clone()这个方法会在内存中开辟一个新空间，并将当前对象堆中的内容复制过去
             *     如果是基本数据类型，则是直接把值复制过去。
             *     但如果是引用类型，仅仅只是将引用对象的地址复制过去了而已。这会造成浅拷贝。
             *     旧对象和新对象的引用类型属性是同一块内存空间。
             *     对于String、Double这种不可变的，我们可以不管他，就算引用同一个内存空间，反正它里面的值是固定不会变的
             * */
            newObject = (BigObject)super.clone();
            newObject.innerClass1 = innerClass1.clone();
            newObject.innerClass2 = innerClass2.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return newObject;
    }
    @Override
    public String toString() {
        return "BigObject [field1=" + field1 + ", field2=" + field2 + ", field3=" + field3 + ", field4=" + field4
                + ", innerClass1=" + innerClass1 + ", innerClass2=" + innerClass2 + "]";
    }
    
}

class InnerClass1 implements Cloneable{
    int field1;
    Double field2;
    String field3;
    boolean field4;
    InnerClass3 innerClass;
    @Override
    public String toString() {
        return "InnerClass1 [field1=" + field1 + ", field2=" + field2 + ", field3=" + field3 + ", field4=" + field4
                + ", innerClass=" + innerClass + "]";
    }
    public InnerClass1(int field1, Double field2, String field3, boolean field4, InnerClass3 innerClass) {
        this.field1 = field1;
        this.field2 = field2;
        this.field3 = field3;
        this.field4 = field4;
        this.innerClass = innerClass;
    }
    /**
     *     重写克隆方法，这是深拷贝的关键
     * */
    @Override
    public InnerClass1 clone() {
        InnerClass1 newObject = null;
        try {
            /** 
             *     这里一定要调用父类的构造方法，决不能调用自己子类的构造方法，不然会死循环的
             *     super.clone()这个方法会在内存中开辟一个新空间，并将当前对象堆中的内容复制过去
             *     如果是基本数据类型，则是直接把值复制过去。
             *     但如果是引用类型，仅仅只是将引用对象的地址复制过去了而已。这会造成浅拷贝。
             *     旧对象和新对象的引用类型属性是同一块内存空间。
             *     对于String、Double这种不可变的，我们可以不管他，就算引用同一个内存空间，反正它里面的值是固定不会变的
             * */
            newObject = (InnerClass1)super.clone();
            newObject.innerClass = innerClass.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return newObject;
    }
}
class InnerClass2 implements Cloneable{
    int field1;
    Double field2;
    String field3;
    boolean field4;
    @Override
    public String toString() {
        return "InnerClass2 [field1=" + field1 + ", field2=" + field2 + ", field3=" + field3 + ", field4=" + field4
                + "]";
    }
    public InnerClass2(int field1, Double field2, String field3, boolean field4) {
        this.field1 = field1;
        this.field2 = field2;
        this.field3 = field3;
        this.field4 = field4;
    }
    /**
     *     重写克隆方法，这是深拷贝的关键
     * */
    @Override
    public InnerClass2 clone() {
        InnerClass2 newObject = null;
        try {
            /** 
             *     这里一定要调用父类的构造方法，决不能调用自己子类的构造方法，不然会死循环的
             *     super.clone()这个方法会在内存中开辟一个新空间，并将当前对象堆中的内容复制过去
             *     如果是基本数据类型，则是直接把值复制过去。
             *     但如果是引用类型，仅仅只是将引用对象的地址复制过去了而已。这会造成浅拷贝。
             *     旧对象和新对象的引用类型属性是同一块内存空间。
             *     对于String、Double这种不可变的，我们可以不管他，就算引用同一个内存空间，反正它里面的值是固定不会变的
             * */
            newObject = (InnerClass2)super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return newObject;
    }
}
class InnerClass3 implements Cloneable{
    int field1;
    Double field2;
    String field3;
    boolean field4;
    @Override
    public String toString() {
        return "InnerClass3 [field1=" + field1 + ", field2=" + field2 + ", field3=" + field3 + ", field4=" + field4
                + "]";
    }
    public InnerClass3(int field1, Double field2, String field3, boolean field4) {
        this.field1 = field1;
        this.field2 = field2;
        this.field3 = field3;
        this.field4 = field4;
    }
    /**
     *     重写克隆方法，这是深拷贝的关键
     * */
    @Override
    public InnerClass3 clone() {
        InnerClass3 newObject = null;
        try {
            /** 
             *     这里一定要调用父类的构造方法，决不能调用自己子类的构造方法，不然会死循环的
             *     super.clone()这个方法会在内存中开辟一个新空间，并将当前对象堆中的内容复制过去
             *     如果是基本数据类型，则是直接把值复制过去。
             *     但如果是引用类型，仅仅只是将引用对象的地址复制过去了而已。这会造成浅拷贝。
             *     旧对象和新对象的引用类型属性是同一块内存空间。
             *     对于String、Double这种不可变的，我们可以不管他，就算引用同一个内存空间，反正它里面的值是固定不会变的
             * */
            newObject = (InnerClass3)super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return newObject;
    }

}