23模式---原型模式（浅拷贝和深拷贝）
原型模式是一种创建型设计模式，Prototype模式允许一个对象再创建另外一个可定制的对象，根本无需知道任何如何创建的细节,工作原理是:通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建。
简单的说就是对象本身提供了一个可复制（克隆）的接口，用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。
这个就有两个疑问了，返回一个对象？
-
不是有单例模式吗？
因为单例模式返回的对象的同一个，而有些场景下虽然使用相同属性值的类，但是再某个方法中出现变化的时候，不希望影响其它对的属性值。举一个不巧当的例子，比如双胞胎出生后很多信息都相同，都是未婚，可以说属性值一样，但是有一天老二结婚了媳妇是小红，不能说老大立马也结婚，媳妇也是小红吧？简单的说就是单例模式无法满足所有遇见的问题。
-
不是有工厂模式吗？
举一个例子那就是抽象工厂类，以小米手机为抽象接口，然后生长的手机有不同的型号A,B,C。然后对用的工厂类有A,B,C等工厂。所以只要创建一个新的对象，就需要有新的工厂类，这个是工厂模式的优势，也是其也会让代码逻辑变复杂。
而克隆模式就是通过一个实例小米手手机对象克隆出需要的手机对象，然后根据ABC型号，来换对应ABC属性值即可。
-
这又产生了一个问题：既然通过实例克隆，然后再修改属性，那么我干嘛不直接通过new来实现，而通过克隆呢？不是故意让代码变得更繁琐吗？
不是的， 因为某些复杂的对象实例的时候拷贝（克隆）的效率一般对构造的效率要高，但是也不是所有的都是快的，比如简单逻辑拷贝（克隆）也就没有直接new的效率高。
-
因为java中自动拷贝功能，所以先试一下克隆对比构造的创建实例的效率：
先来一个简单逻辑的：
public class test implements Cloneable {
public static void main(String[] args) throws CloneNotSupportedException {
Long start1= System.currentTimeMillis();
Phone p=new Phone("小米",1999,"red");
for (int i = 0; i <9999999 ; i++) {
new Phone(p.getBrandname(),p.price,p.getColor());
}
Long end1= System.currentTimeMillis();
System.out.println("new创建1万实例："+ (end1-start1));
Long start2= System.currentTimeMillis();
Phone p2=new Phone("小米",1999,"red");
for (int i = 0; i <9999999 ; i++) {
p2.clone();
}
Long end2= System.currentTimeMillis();
System.out.println("原型创建1万实例："+ (end2-start2));
}
}
class Phone implements Cloneable{
String brandname;
double price;
String color;
public Phone() {
}
public Phone(String brandname, double price, String color) {
this.brandname = brandname;
this.price = price;
this.color = color;
}
public String getBrandname() {
return brandname;
}
public double getPrice() {
return price;
}
public String getColor() {
return color;
}
@Override
public Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
故意来一个在构造对象的时候调用一个方法：
public class test implements Cloneable {
public static void main(String[] args) throws CloneNotSupportedException {
Long start1= System.currentTimeMillis();
Phone p=new Phone("小米",1999,"red");
for (int i = 0; i <9999999 ; i++) {
new Phone(p.getBrandname(),p.price,p.getColor());
}
Long end1= System.currentTimeMillis();
System.out.println("new创建1万实例："+ (end1-start1));
Long start2= System.currentTimeMillis();
Phone p2=new Phone("小米",1999,"red");
for (int i = 0; i <9999999 ; i++) {
p2.clone();
}
Long end2= System.currentTimeMillis();
System.out.println("原型创建1万实例："+ (end2-start2));
}
}
class Phone implements Cloneable{
String brandname;
double price;
String color;
public Phone() {
}
public Phone(String brandname, double price, String color) {
this.brandname = brandname;
this.price = getRealpice(price);
this.color = color;
}
public double getRealpice(double price){
for (int i = 0; i < 5000; i++) {
new String();
}
return price;
}
public String getBrandname() {
return brandname;
}
public double getPrice() {
return price;
}
public String getColor() {
return color;
}
@Override
public Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
所以：只有再较为复杂的逻辑下，复制（克隆）方式的效率才会高于通过构造函数创建的对象。
Cloneable接口使用细节
java本身就支持原型模式（对象自带克隆方法），所以不需要我们手动去写如何实现这个克隆方法，所以现在看一使用细节。
先看一下Cloneable这个接口：
看了一下其本身没有定义任何方法，但是为什么还要写实现这个接口呢，而类可以种的clone方法显示其为重写方法，说明其在父类，所以看一些Object类
看英文说明，指数可以知道：
- 此方法是native修饰，说明是系统方法，其具体实现逻辑是C写的底层实现的。其应该是直接在内存堆种进行复制新对象的。
- 为什么要重写conle方法，而通过super调用因为其protected修饰，只能通子类来通过spuer来调用。
- 返回的对象和被克隆的对象其是两个不同的对象，两者不是同一个对象，但是是同一个class类实例化的。
- 虽然Cloneable没有写方法，但是如果不写，调用重写后的clone方法就会报错。
还有一点这里没有说到的，那就是clnoe方法克隆的对象是只能克隆基本数据类型，如果引用类型的属性，还是共有的，这个就又分浅拷贝和深拷贝了。（这个JavaScript种也聊过这个）
当然如果通过clnoe方法自己写行不行比如：
class Phone implements Cloneable{
String brandname;
double price;
String color;
public Phone() {
}
public Phone(String brandname, double price, String color) {
this.brandname = brandname;
this.price = price;
this.color = color;
}
public String getBrandname() {
return brandname;
}
public double getPrice() {
return price;
}
public String getColor() {
return color;
}
public void setBrandname(String brandname) {
this.brandname = brandname;
}
public void setPrice(double price) {
this.price = price;
}
public void setColor(String color) {
this.color = color;
}
// 自己这样写
public Object clone1() {
Phone p=new Phone();
p.setBrandname(this.getBrandname());
p.setPrice(this.getPrice());
p.setColor(this.getColor());
return p;
}
}
是否可以实现呢？当然也是可以的，不过创建一个对象都写一个，如果属性由几十个的话，是否就很麻烦，所以人家已经写好了，干嘛不直接用呢？不过说句实话，自己这样写有可能效率比调用系统的方法更快，毕竟所有的属性都知道得，不用通过反射再创建了。
浅拷贝
看一下java种通过实现cloneable接口实现的拷贝为什么说是浅拷贝。
public class test implements Cloneable {
public static void main(String[] args) throws CloneNotSupportedException {
String[] arr = {"老头环", "奎爷", "神秘臂力"};
TestObject testObject = new TestObject("张三", Arrays.asList(arr));
System.out.println("testObject原本数据：" + testObject.toString());
TestObject testObject1 = (TestObject) testObject.clone();
testObject1.setName("李四");
System.out.println("testObject的数据： " + testObject.toString());
System.out.println("testObject1的数据： " + testObject1.toString());
Collections.reverse(testObject.arr);
System.out.println("testObject的数据： " + testObject.toString());
System.out.println("testObject1的数据： " + testObject1.toString());
}
}
class TestObject implements Cloneable {
String name;
List<String> arr;
public TestObject(String name, List<String> arr) {
this.name = name;
this.arr = arr;
}
public void setName(String name) {
this.name = name;
}
public void setArr(List<String> arr) {
this.arr = arr;
}
@Override
public Object clone() throws CloneNotSupportedException {
return super.clone();
}
@Override
public String toString() {
return "TestObject{" +
"name='" + name + '\'' +
", arr=" + Arrays.toString(arr.toArray()) +
'}';
}
}
可以看出克隆的如果是基本数据类型或者String的话克隆后的对象，不会影响彼此，但是如果是引用数据类型的话，就会影响彼此。所以一般的时候除非确定属性不是引起类型，不然不要如此使用。
深拷贝
深拷贝的的也可以通过Cloneable实现，但是先声明其由一定的局限性。
方式1：
public class test {
public static void main(String[] args) throws CloneNotSupportedException {
TestObjectA testObject = new TestObjectA("张三", new TestObjectB());
System.out.println("testObject原本数据：" + testObject.toString());
TestObjectA testObject1 = (TestObjectA) testObject.clone();
System.out.println("testObject的数据： " + testObject.toString());
System.out.println("testObject1的数据： " + testObject1.toString());
}
}
class TestObjectA implements Cloneable {
String name;
TestObjectB testObjectB;
public TestObjectA(String name, TestObjectB testObjectB) {
this.name = name;
this.testObjectB = testObjectB;
}
@Override
public String toString() {
return "TestObjectA{" +
" testObjectB=" + testObjectB.hashCode() +
'}';
}
@Override
public Object clone() throws CloneNotSupportedException {
TestObjectA deep=null;
deep= (TestObjectA) super.clone();
deep.testObjectB= (TestObjectB) this.testObjectB.clone();
return deep;
}
}
class TestObjectB implements Cloneable{
@Override
public Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
这样似乎解决了浅拷贝的问题，但是其有一个弱点，那就是如果TestObjectB的属性也引用了对象，或者说TestObjectA都有多个引用属性呢？是不是代码写起来就麻烦了很多。
不过借鉴一下我再JavaScript种通过Json和对象的转换来解决深拷贝的问题。当然java种除非调用第三方的json包才可以，不过通过这个想法可以相到一件事情，那就是可以通过序列化来实现这个问题。
public class test {
public static void main(String[] args) throws CloneNotSupportedException {
TestObjectA testObject = new TestObjectA("张三", new TestObjectB());
System.out.println("testObject原本数据：" + testObject.toString());
TestObjectA testObject1 = (TestObjectA) testObject.clone();
System.out.println("testObject的数据： " + testObject.toString());
System.out.println("testObject1的数据： " + testObject1.toString());
// Json
}
}
class TestObjectA implements Serializable {
String name;
TestObjectB testObjectB;
public TestObjectA(String name, TestObjectB testObjectB) {
this.name = name;
this.testObjectB = testObjectB;
}
@Override
public String toString() {
return "TestObjectA{" +
" testObjectB=" + testObjectB.hashCode() +
'}';
}
@Override
public Object clone() throws CloneNotSupportedException {
ByteArrayOutputStream bos = null;
ObjectOutputStream oos = null;
ByteArrayInputStream bis = null;
ObjectInputStream ois = null;
Object object = null;
try {
bos = new ByteArrayOutputStream();
oos = new ObjectOutputStream(bos);
oos.writeObject(this);
bis = new ByteArrayInputStream(bos.toByteArray());
ois = new ObjectInputStream(bis);
object = ois.readObject();
ois.close();
bis.close();
oos.close();
bos.close();
} catch (Exception e) {
System.out.println(e);
}
return object;
}
}
class TestObjectB implements Serializable{
}
而这种方式才是再java种一般解决深拷贝问题的方式。
总结
-
优势：
性能提高。 逃避构造函数的约束。
-
缺点
配备克隆方法需要对类的功能进行通盘考虑，这对于全新的类不是很难，但对于已有的类不一定很容易，特别当一个类引用不支持串行化的间接对象，或者引用含有循环结构的时候。 必须实现 Cloneable 接口或者Serializable接口。
-
用场景：
- 1、资源优化场景。
- 2、类初始化需要消化非常多的资源，这个资源包括数据、硬件资源等。
- 3、性能和安全要求的场景。
- 4、通过 new 产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式。
- 5、一个对象多个修改者的场景。
- 6、一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可以考虑使用原型模式拷贝多个对象供调用者使用。
- 7、在实际项目中，原型模式很少单独出现，一般是和工厂方法模式一起出现，通过 clone 的方法创建一个对象，然后由工厂方法提供给调用者。