原型设计模式

原型模式

说明

• 意义

我在研究某一个知识的时候，第一件事我会先考虑这个知识的作用是什么，可以帮我解决什么样的问题
有好多时候我在学习的时候，总是学完了才发现自己学了个寂寞。
尤其是在学习设计模式的时，我会感觉普通的写法也能实现的功能，为什么还要用设计模式呢？
所以我在学习的时候，要首先弄明白设计模式的意义
我搜肠刮肚好长时间，我发现我这么多年的开发经验下，竟然没有一个地方用过原型模式，也想不出来在哪里能用到原型模式
不过用不用得到并不重要，就像是我们小时候背古诗一样，在我们被诗的时候肯定想不到某一天写情书的时候就用到了。
简而言之，原型模式就是我们用来复制一些复杂的对象时用到的一种简单的功能。方便我们大量的复制复杂的对象。

• 优缺点

优点: 原型模式是在内存中二进制流的拷贝,要比直接new 一个对象性能好很多,特别是要在一个循环体内产生大量的对象时,原型模式可以更好的体现其有点
缺点: 它的优点也是缺点,直接在内存汇总拷贝,构造函数是不会执行的,在实际开发中,应该注意这个潜在的问题.优点是减少了约束,缺点也是减少了约束,需要再时机应用的时候考虑 

浅拷贝

• 创建对象

public class Sheep implements Cloneable{

    private String name;
    private int age;
    private String color;

    public Sheep() {
    }

    public Sheep(String name, int age, String color) {
        this.name = name;
        this.age = age;
        this.color = color;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

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

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    @Override
    public String toString() {
        return "Sheep{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", color='" + color + '\'' +
                '}';
    }

    //克隆该实例，使用默认的克隆方法完成
    @Override
    protected Object clone() {
        Sheep sheep = null;
        try {
            sheep = (Sheep) super.clone();
        } catch (CloneNotSupportedException e) {
            System.out.println("克隆出现异常");
            System.out.println(e.getMessage());
        }
        return sheep;
    }
}

• 克隆

public class Client {
    public static void main(String[] args) {

        Sheep sheep =new Sheep("tom", 1, "白");
        Sheep sheep2 = (Sheep) sheep.clone();
        Sheep sheep3 = (Sheep) sheep.clone();
        Sheep sheep4 = (Sheep) sheep.clone();
        Sheep sheep5 = (Sheep) sheep.clone();

        System.out.println(sheep);
        System.out.println(sheep2);
        System.out.println(sheep3);
        System.out.println(sheep4);
        System.out.println(sheep5);

    }
}

• 说明

如果已经写了一大片的代码，然后突然sheeo类发生了改版（比如增加了某属性）
在业务代码中不需要逐个的增加改属性，不用任何改变，所有的sheep都会默认的增加该属性 

深拷贝

• 准备

import java.io.Serializable;
import java.util.Optional;

public class DeepCloneAbleTarget implements Serializable , Cloneable {



    private String cloneName;
    private String cloneClass;

    public DeepCloneAbleTarget() {
    }

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

    public String getCloneName() {
        return cloneName;
    }

    public void setCloneName(String cloneName) {
        this.cloneName = cloneName;
    }

    public String getCloneClass() {
        return cloneClass;
    }

    public void setCloneClass(String cloneClass) {
        this.cloneClass = cloneClass;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

• 准备二

import sun.reflect.generics.tree.BaseType;
import java.io.*;

public class DeepProtoType implements Serializable , Cloneable {

    public String name;
    public DeepCloneAbleTarget deepCloneAbleTarget;

    public DeepProtoType() {
    }

    //方式一   -----   深拷贝
    @Override
    protected Object clone() throws CloneNotSupportedException {
        Object deep = null;
        // 完成基本数据类型的处理
        deep= super.clone();
        // 对引用属性单独处理
        DeepProtoType deepProtoType = (DeepProtoType) deep;
        deepProtoType.deepCloneAbleTarget = (DeepCloneAbleTarget) deepCloneAbleTarget.clone();
        return deepProtoType;
    }

    //方式二   -----   序列化
    public Object 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);
            DeepProtoType copyObject = (DeepProtoType) ois.readObject();
            return copyObject;
        }catch (Exception e){
            e.printStackTrace();
            return null;
        }finally {
            try {
                bos.close();
                oos.close();
                bis.close();
                ois.close();
            }catch (Exception e){
                System.out.println(e.getMessage());
            }
        }
    }
}

• 方式一：反射

public class Client {

    public static void main(String[] args) throws CloneNotSupportedException {

        DeepProtoType deepProtoType = new DeepProtoType();
        deepProtoType.name = "宋江";
        deepProtoType.deepCloneAbleTarget = new DeepCloneAbleTarget("dada","name");

        DeepProtoType deepProtoType1 = (DeepProtoType)deepProtoType.clone();
        System.out.println(deepProtoType.deepCloneAbleTarget.hashCode());
        System.out.println(deepProtoType1.deepCloneAbleTarget.hashCode());
        System.out.println(deepProtoType.deepCloneAbleTarget == deepProtoType1.deepCloneAbleTarget);
    }
}

• 方式二：序列化

public class Client2 {
    public static void main(String[] args) {
        DeepProtoType deepProtoType = new DeepProtoType();
        deepProtoType.name = "宋江";
        deepProtoType.deepCloneAbleTarget = new DeepCloneAbleTarget("dada","name");

        DeepProtoType deepProtoType1 = (DeepProtoType) deepProtoType.deepClone();
        System.out.println(deepProtoType1.deepCloneAbleTarget.hashCode());
        System.out.println(deepProtoType.deepCloneAbleTarget.hashCode());
        System.out.println(deepProtoType1.deepCloneAbleTarget == deepProtoType.deepCloneAbleTarget);

    }
}