​一、原型模式介绍

原型模式：原型模式就是从一个对象再创建另外一个可定制的对象，而且不需要知道任何创建的细节。

所谓原型模式，就是java中的克隆技术，以某个对象为原型。复制出新的对象。显然新的对象具备原型对象的特点。效率高（避免了重新执行构造过程步骤）

克隆类似于new，但和new不同。new创建新的对象属性采用的是默认值。克隆出来的对象的属性值完全和原型对象相同。并且克隆出的新对象不会影响原型对象，克隆后。还可以再修改克隆对象的值。

要实现原型模式，必须实现Cloneable接口，而这个接口里面是空的。

Cloneable接口是一个空接口，使用Cloneable接口都不用导入包。而clone方法是属于Object对象的。如果要克隆某个对象的话必须实现Cloneable接口

1
2
3
4
5
6
7
*  @author   unascribed
  *  @see      java.lang.CloneNotSupportedException
  *  @see      java.lang.Object#clone()
  *  @since    JDK1. 0
  */
public  interface  Cloneable {
}

重写Object对象的clone方法，clone方法为本地方法。效率比较高

1
protected  native  Object clone()  throws  CloneNotSupportedException;

如果我们要克隆某个对象有浅克隆和深克隆

浅克隆：copy该对象，然后保留该对象原有的引用。也就是说不克隆该对象的属性。

深克隆：copy该对象，并且把该对象的所有属性也克隆出一份新的。

二、代码实现

1、浅克隆代码实现：

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
/**
  * 原型模式:浅克隆
  * Cloneable是一个空接口（标记接口），是一个规范。但是如果要克隆这个类对象的话必须实现Cloneable接口
  */
public  class  Sheep  implements  Cloneable{
     private  String sname;
     private  Date birthday;
     
     /**
      * 重写Object对象的clone方法
      */
     @Override
     protected  Object clone()  throws  CloneNotSupportedException {
         //直接调用Object对象的clone方法
         Object obj =  super .clone();
         return  obj;
     }
     //省略get，set方法和构造方法
     
}
 
/**
  * 测试原型模式（浅克隆）
  */
public  class  Test {
     public  static  void  main(String[] args)  throws  Exception {
         Date date =  new  Date(1274397294739L);
         Sheep s1 =  new  Sheep( "原型羊" ,date);
         Sheep s2 = (Sheep) s1.clone(); //克隆一个羊
         System.out.println(s1);
         System.out.println(s1.getSname());
         System.out.println( "原日期：" +s1.getBirthday());
         date.setTime(34732834827389L); //改变原有date的值
         System.out.println( "改变后的日期：" +date.toString());
         
         //克隆羊的信息
         System.out.println( "---------------------------------" );
         System.out.println(s2);
         System.out.println(s2.getSname());
         System.out.println(s2.getBirthday()); //此时的birthday日期使用的是改变后的日期对象引用
     }
}

最后的结果为：克隆的对象仍然保留了原有对象的引用，值随着改变而改变

1
2
3
4
5
6
7
8
com.fz.prototype.Sheep @153f67e
原型羊
原日期：Fri May  21  07 : 14 : 54  CST  2010
改变后的日期：Mon Aug  22  17 : 40 : 27  CST  3070
---------------------------------
com.fz.prototype.Sheep @18f51f
原型羊
Mon Aug  22  17 : 40 : 27  CST  3070

 

2、深克隆代码实现：克隆对象的同时，把该对象的属性也连带着克隆出新的。

深克隆只需要在clone方法中将该对象的属性也克隆即可

1
2
3
4
5
6
7
8
9
10
11
12
/**
  * 重写Object对象的clone方法
  */
@Override
protected  Object clone()  throws  CloneNotSupportedException {
     //直接调用Object对象的clone方法
     Object obj =  super .clone();
     //深克隆：把对象下的所有属性也克隆出来
     Sheep22 s = (Sheep22) obj;
     s.birthday = (Date)  this .birthday.clone();
     return  s;
}

测试代码不变，结果则会变了。克隆了之后把原来的日期改变后，克隆的对象2的属性则不会被影响。

1
2
3
4
5
6
7
8
com.fz.prototype.Sheep2 @15bdc50
原型羊
原日期：Fri May  21  07 : 14 : 54  CST  2010
改变后的日期：Mon Aug  22  17 : 40 : 27  CST  3070
---------------------------------
com.fz.prototype.Sheep2 @18f51f
原型羊
Fri May  21  07 : 14 : 54  CST  2010

 

3、通过序列化和反序列化来实现深克隆对象：序列化需要原型对象实现Serializable接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
import  java.io.ByteArrayInputStream;
import  java.io.ByteArrayOutputStream;
import  java.io.ObjectInputStream;
import  java.io.ObjectOutputStream;
import  java.util.Date;
 
/**
  * 测试原型模式（利用序列化和反序列化实现深克隆）
  */
public  class  Test3 {
     public  static  void  main(String[] args)  throws  Exception {
         Date date =  new  Date(1274397294739L);
         Sheep s1 =  new  Sheep( "原型羊" ,date);
//      Sheep s2 = (Sheep) s1.clone();//克隆一个羊
         
         //使用序列化和反序列化实现深复制
         //1、将s1对象序列化为一个数组
         //通过ObjectOutputStream流将s1对象读出来给ByteArrayOutputStream流
         ByteArrayOutputStream bos =  new  ByteArrayOutputStream();
         ObjectOutputStream    oos =  new  ObjectOutputStream(bos);
         oos.writeObject(s1);
         //ByteArrayOutputStream流将对象信息转成byte数组，这样byte数组里就包含了对象的数据
         byte [] bytes = bos.toByteArray();
         
         //2、将字节数组中的内容反序列化为一个Sheep对象
         //通过ByteArrayInputStream流读入bytes字节数组中数据，然后传给ObjectInputStream对象输入流
         ByteArrayInputStream bis =  new  ByteArrayInputStream(bytes);
         ObjectInputStream    ois =  new  ObjectInputStream(bis);
         //通过ObjectInputStream返回一个Sheep对象
         Sheep s2 = (Sheep) ois.readObject();
 
         //原型羊的信息
         System.out.println(s1);
         System.out.println( "原日期：" +s1.getBirthday());
         date.setTime(34732834827389L); //改变原有date的值
         System.out.println( "改变后的日期：" +date.toString());
         //克隆羊的信息
         System.out.println( "---------------------------------" );
         System.out.println(s2);
         System.out.println(s2.getBirthday());
     }
}

通过序列化和反序列化的结果，最终结果还是和深克隆一样。

1
2
3
4
5
6
7
8
9
10
11
com.fz.prototype.Sheep @1a116c9
 
原日期：Fri May  21  07 : 14 : 54  CST  2010
 
改变后的日期：Mon Aug  22  17 : 40 : 27  CST  3070
 
---------------------------------
 
com.fz.prototype.Sheep @7eb6e2
 
Fri May  21  07 : 14 : 54  CST  2010

 

三、测试克隆对象的效率

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
package  com.fz.prototype;
/**
  * 测试clone对象的效率
  */
public  class  TestClone {
     //new 对象
     public  static  void  testNew( int  size){
         long  start = System.currentTimeMillis();
         for  ( int  i =  0 ; i < size; i++) {
             Laptop l =  new  Laptop();
         }
         long  end = System.currentTimeMillis();
         System.out.println( "new 对象耗时：" +(end-start));
     }
     //clone 对象
     public  static  void  testClone( int  size){
         long  start = System.currentTimeMillis();
         Laptop l =  new  Laptop();
         for  ( int  i =  0 ; i < size; i++) {
             try  {
                 Laptop temp = (Laptop) l.clone();
             }  catch  (CloneNotSupportedException e) {
                 e.printStackTrace();
             }
         }
         long  end = System.currentTimeMillis();
         System.out.println( "clone 对象耗时：" +(end-start));
     }
     public  static  void  main(String[] args) {
         testNew( 1000 );
         testClone( 1000 );
     }
}
 
class  Laptop  implements  Cloneable{
     public  Laptop() {
         //模拟创建Laptop对象的时候比较耗时
         try  {
             Thread.sleep( 10 );
         }  catch  (InterruptedException e) {
             e.printStackTrace();
         }
     }
     @Override
     protected  Object clone()  throws  CloneNotSupportedException {
         return  super .clone();
     }
}

最后结果为：

new 对象耗时：10063

clone 对象耗时：10

 

四、使用场景

原型模式适用场景：如果某个对象new的过程中很耗时，则可以考虑使用原型模式。

Spring框架中bean对象的创建就两种模式：单例模式或者原型模式