设计模式系列之--原型模式

原型模式

这种类型的设计模式属于创建型模式，它提供了一种创建对象的方式。
是不是创建型模式的核心就是不new对象hhh
原型模式与其他两种创建型模式不同 主要用于克隆对象
当需要一个与原来对象一模一样的对象时就可以用原型模式进行创建
主要是使用clone方法 和序列化反序列化的方式进行复制
复制来的对象 要比new出来的对象效率要高 而且当需要复制的目标对象发生改变时 此时复制出来的对象就也是新状态的对象
根据复制情况不同可以分为浅拷贝和深拷贝
(1)浅拷贝 只会复制引用属性的地址不会复制一份引用类型的属性
(2)深拷贝 都会复制
深拷贝说明
(1) 重写 clone
对于不是引用类型属性仍然使用浅拷贝
单独对引用类型属性调用它的clone方法再次浅拷贝
即可实现深拷贝
(2) 序列化反序列化
通过io将对象序列化
再通过io去除反序列化取出对象 完成深拷贝

---

1. 浅拷贝
   1. 直接使用Object的clone方法即可完成浅拷贝
2. 深拷贝
   1. 重写clone方法完成深拷贝
   2. 通过序列化和反序列化机制完成深拷贝

import java.io.*;

//原型模式
public class Clone {
    public static void main(String[] args) throws CloneNotSupportedException {
        //方式1 重写clone深拷贝
        DeepProtyoType deepProtyoType = new DeepProtyoType();
        deepProtyoType.name = "xiaoming";
        deepProtyoType.deepCloneAbleTarget =
                new DeepCloneAbleTarget("honghong","renlei");

        DeepProtyoType clone = (DeepProtyoType) deepProtyoType.clone();
        System.out.println(clone.deepCloneAbleTarget.hashCode() + " " + deepProtyoType.deepCloneAbleTarget.hashCode());
		
		//方式2 通过序列化 和反序列化完成深拷贝
        DeepProtyoType deepProtyoType1 = deepProtyoType.deepClone();
        System.out.println(deepProtyoType1.deepCloneAbleTarget.hashCode() + " " + deepProtyoType.deepCloneAbleTarget.hashCode());

    }
}

//目标类
class DeepProtyoType implements Serializable,Cloneable{

    public String name;
    public DeepCloneAbleTarget deepCloneAbleTarget;

    //重写clone实现深拷贝
    @Override
    protected Object clone() throws CloneNotSupportedException {
        Object deep = null;
        //先浅拷贝属性
        deep = super.clone();
        //对引用类型属性进行单独处理
        //单独调用引用类型中的clone
        DeepProtyoType deepProtyoType = (DeepProtyoType) deep;
        deepProtyoType.deepCloneAbleTarget = (DeepCloneAbleTarget) deepCloneAbleTarget.clone();

        return deepProtyoType;

    }

    //序列化克隆
    public DeepProtyoType deepClone(){
        ByteArrayOutputStream bos = null;
        ObjectOutputStream oos = null;
        ByteArrayInputStream bis = null;
        ObjectInputStream ois = null;

        try{
            bos = new ByteArrayOutputStream();
            oos = new ObjectOutputStream(bos);
            oos.writeObject(this);//序列化对象

            bis = new ByteArrayInputStream(bos.toByteArray());
            ois = new ObjectInputStream(bis);
            DeepProtyoType o = (DeepProtyoType) ois.readObject();
            return o;
        }catch (Exception e){
            System.out.println(e.getMessage());
            return null;
        } finally {
            try {
                assert bos != null;
                bos.close();
                assert oos != null;
                oos.close();
                assert bis != null;
                bis.close();
                assert ois != null;
                ois.close();
            } catch (Exception ignored){}
        }
    }

    @Override
    public String toString() {
        return "DeepProtyoType{" +
                "name='" + name + '\'' +
                ", deepCloneAbleTarget=" + deepCloneAbleTarget +
                '}';
    }
}

class DeepCloneAbleTarget implements Serializable,Cloneable {
    private static final long seriaVersionUID = 1L;

    private String cloneName;

    private String cloneClass;

    public DeepCloneAbleTarget(String cloneName, String cloneClass) {
        this.cloneName = cloneName;
        this.cloneClass = cloneClass;
    }

	//直接通过clone 完成浅拷贝
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    @Override
    public String toString() {
        return "DeepCloneAbleTarget{" +
                "cloneName='" + cloneName + '\'' +
                ", cloneClass='" + cloneClass + '\'' +
                '}';
    }
}