原型模式

一、原型模式（Prototype）
定义：用原型实例指定创建对象的种类，并且通过拷贝这些原型来创建新的实例。

    换句话说，原型模式就是通过复制现在已经存在的对象来创建一个新的对象。copy和原型的内容一样，但是又是彼此隔离的。即在clone之后，改变其中一个不影响另外一个。


二、原型的意义：

   有的时候，我们需要一个实例时，并且，当创建一个实例的过程比较复杂或者说是昂贵时，比如，创建实例的构造函数非常的复杂，在执行这个构造函数时会消耗较长的时间，
同时呢，这个构造函数中的一些信息又没有什么变化（也就是说创建第一个实例时初始化信息是这样的，创建第二个实例时初始化信息还是还是这样的），那么直接使用 new 来创建这样一个实例就显得太昂贵了，最好的解决方法，并不是使用 new 来实例化一个对象，
而是使用克隆，也就是复制，克隆呢，就是通过复制现在已经有了的实例来创建新的实例，
这样有什么好处呢？很明显，这样实现呢，客户端根本就不知道具体要实例化的是哪一个类，
它只知道是复制了，但具体的实例化情况，它却是一无所知的，这样便对客户端进行了隐藏，
同时，复制一个对象一般情况下会比创建一个对象性能更高（当然有时候也不一定，只是一般情况而已），其实上面所提到的就是下面要介绍的一个设计模式--原型模式（Prototype）


三、Object默认的clone机制：

    Object的clone的行为是最简单的。以堆上的内存存储解释的话（不计内务内存），对一个对象a的clone就是在堆上分配一个和a在堆上所占存储空间一样大的一块地方，然后把a的堆上内存的内容复制到这个新分配的内存空间上。

例子：
class User implements Cloneable {

String name;
int age;

@Override
public Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
public class Snippet {

public static void main(String[] args) {
User user = new User();
user.name="sss";
user.age = 20;

User copy;
try {
copy = (User) user.clone();
copy.age = 30;
System.out.println(user.age);
System.out.println(copy.age);

// name因为是引用类型，所以copy和原型的引用是同一的。
// String为不可变类。没有办法可以通过对copy.name的字符串的操作改变这个字符串。
// 改变引用新的对象不会影响原型。
copy.name = "newname";
System.out.println(user.name);
System.out.println(copy.name);
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}

}

}



浅复制和深复制区别？

浅复制呢又称为浅拷贝，深复制又称为深拷贝。
浅复制的话，就是通过一个原型实例（这里暂称为老对象）克隆所得到的对象（这里暂时称为新对象），而这个新对象中所有的值类型变量都含有与老对象相同的值，但是，新对象所有的对其他对象的引用却是和老对象指向同一个地方，即对引用类型来说，老对象和新对象指向同一个引用对象。深复制呢，和浅复制就一点不同，那就是，新对象所有的对其他对象的引用都是指向了复制过的对象，而不再是和老对象指向同一个对象。
    比如，上面提到的员工类中的员工信息类的引用，如果使用深复制的话，便可以解决上面提出的问题，使用深复制，可以先把老员工的员工信息类复制一遍（也就是创建了新的员工信息），然后让新员工的员工信息引用指向这个复制而来的新的员工信息，


如何clone？
clone三部曲。
1 声明实现Cloneable接口。
2 调用super.clone拿到一个对象，如果父类的clone实现没有问题的话，在该对象的内存存储中，所有父类定义的field都已经clone好了，该类中的primitive和不可变类型引用也克隆好了，可变类型引用都是浅copy。
3 把浅copy的引用指向原型对象新的克隆体。
给个例子。


class User implements Cloneable {
String name;
int age;

@Override
public User clone() throws CloneNotSupportedException {
return (User) super.clone();
}
}

class Account implements Cloneable {
User user;
long balance;

@Override
public Account clone() throws CloneNotSupportedException {
Account account = null;

account = (Account) super.clone();
if (user != null) {
account.user = user.clone();
}

return account;
}
}


注意点：
1.在考虑clone时，primitive和不可变对象类型是可以同等对待的。
2.效率和简单性，简单的copy一个对象在堆上的的内存比遍历一个对象网然后内存深copy明显效率高并且简单。
3.有可能破坏语义。如果A实现了Cloneable，同时有一个引用指向B，该B实现为单例模式，如果直接复制内存进行深copy的话，破坏了B的单例模式。
4.方便且更灵活，如果A引用一个不可变对象，则内存deep copy是一种浪费。