简单了解java原型模式

http://c.biancheng.net/view/1343.html
https://www.cnblogs.com/shakinghead/p/7651502.html

原型（Prototype）模式的定义

用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型相同或相似的新对象。

原型模式的优点：

java自带的原型模式基于内存二进制流的复制，在性能上比直接 new 一个对象更加优良。
可以使用深克隆方式保存对象的状态，使用原型模式将对象复制一份，并将其状态保存起来，简化了创建对象的过程，以便在需要的时候使用（例如恢复到历史某一状态），可辅助实现撤销操作。

原型模式的缺点：

需要为每一个类都配置一个 clone 方法
clone 方法位于类的内部，当对已有类进行改造的时候，需要修改代码，违背了开闭原则。
当实现深克隆时，需要编写较为复杂的代码，而且当对象之间存在多重嵌套引用时，为了实现深克隆，每一层对象对应的类都必须支持深克隆，实现起来会比较麻烦。因此，深克隆、浅克隆需要运用得当。

原型模式的结构与实现

由于 Java 提供了对象的 clone() 方法，所以用 Java 实现原型模式很简单。

1. 模式的结构

原型模式包含以下主要角色。

抽象原型类：规定了具体原型对象必须实现的接口。
具体原型类：实现抽象原型类的 clone() 方法，它是可被复制的对象。
访问类：使用具体原型类中的 clone() 方法来复制新的对象。

2.实现

/**
 * 原型模式Prototype
 * 通过复制已有实例快速创建一个新实例
 * 原型模式有浅克隆、深克隆的区别：浅克隆的结果
 */
public class Realizetype implements Cloneable {
    private String name;
    private Age age;

    public String getName() {
        return name;
    }

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

    public Age getAge() {
        return age;
    }

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

    public Realizetype(){
        System.out.println("帅气的我出现了");
    }

    public Realizetype clone() throws CloneNotSupportedException {
        System.out.println("又一个帅气的我出现了");
        return (Realizetype) super.clone();
    }

    public static void main(String[] args) {
        try {
            Age age = new Age();
            age.setAge(2);
            Realizetype realizetype = new Realizetype();
            realizetype.setName("张三");
            realizetype.setAge(age);
            System.out.println("我是,name=" + realizetype.getName());
            System.out.println("年龄,age=" + realizetype.getAge().getAge());
            System.out.println("##########");

            Realizetype realizetype1 = realizetype.clone();
            System.out.println("张三的复制体,name=" + realizetype1.getName());
            System.out.println("张三的复制体,age=" + realizetype1.getAge().getAge());
            System.out.println("##########");

            realizetype.setName("李四");
            age.setAge(9);
            realizetype.setAge(age);
            System.out.println("张三改名为李四，年龄变为9");
            System.out.println("张三的新,name=" + realizetype.getName());
            System.out.println("张三的新,age=" + realizetype.getAge().getAge());
            System.out.println("##########");

            System.out.println("张三的复制体,name=" + realizetype1.getName());
            System.out.println("张三的复制体,age=" + realizetype1.getAge().getAge());
            System.out.println("##########");

            System.out.println(realizetype == realizetype1);
            System.out.println(realizetype.age == realizetype1.age);
        } catch (Exception e){
            System.out.println("无碍");
        }
    }
}

运行结果

帅气的我出现了
我是,name=张三
年龄,age=2
##########
又一个帅气的我出现了
张三的复制体,name=张三
张三的复制体,age=2
##########
张三改名为李四，年龄变为9
张三的新,name=李四
张三的新,age=9
##########
张三的复制体,name=张三
张三的复制体,age=9
##########
false
true

可以发现当张三的姓名年龄变更后，张三的复制体姓名不变、年龄变了，其原因是clone()方法为浅拷贝，拷贝的引用数据指向同一内存地址所以System.out.println(realizetype.age == realizetype1.age);为true。
String是一个例外，虽然String是引用数据，但是String类型的数据是存放在常量池中的。

深拷贝

实现方式1-每个类重写clone方法

修改Realizetype的clone方法

public Realizetype clone() throws CloneNotSupportedException {
        System.out.println("又一个帅气的我出现了");
        Realizetype r = (Realizetype) super.clone();
        //克隆Age实例
        r.setAge(getAge().clone());
}

修改Age类，使他继承Cloneable，重写clone方法

public Age clone(){
            Age a = null;
            try {
                a = (Age) super.clone();
            } catch (CloneNotSupportedException e) {
                e.printStackTrace();
            }
            return a;
        }

修改后执行结果

帅气的我出现了
我是,name=张三
年龄,age=2
##########
又一个帅气的我出现了
张三的复制体,name=张三
张三的复制体,age=2
##########
张三改名为李四，年龄变为9
张三的新,name=李四
张三的新,age=9
##########
张三的复制体,name=张三
张三的复制体,age=2
##########
false
false

可以看到深克隆的实例不受本体影响。
这种深克隆的实现方式较为复杂，特别对于属性数量比较多、层次比较深的类而言，每个类都要重写clone方法太过繁琐

实现方式2-通过序列化拷贝

参考https://www.cnblogs.com/shakinghead/p/7651502.html