设计模式系列—原型模式

前言

创新互联公司专业为企业提供峨边彝族网站建设、峨边彝族做网站、峨边彝族网站设计、峨边彝族网站制作等企业网站建设、网页设计与制作、峨边彝族企业网站模板建站服务，十载峨边彝族做网站经验，不只是建网站，更提供有价值的思路和整体网络服务。

  • 23种设计模式速记
  • 单例（singleton）模式
  • 工厂方法（factory method）模式
  • 抽象工厂（abstract factory）模式
  • 建造者/构建器（builder）模式

23种设计模式快速记忆的请看上面第一篇，本篇和大家一起来学习原型模式，在学习原型模式之前我们需要先认识下浅拷贝和深拷贝这两个概念。

浅拷贝和深拷贝
浅拷贝
浅拷贝是按位拷贝对象，它会创建一个新对象，这个对象有着原始对象属性值的一份精确拷贝。如果属性是基本类型，拷贝的就是基本类型的值；如果属性是内存地址（引用类型），拷贝的就是内存地址 ，因此如果其中一个对象改变了这个地址，就会影响到另一个对象。

复制了对象的引用地址，两个对象指向同一个内存地址，所以修改其中任意的值，另一个值都会随之变化。

深拷贝
深拷贝会拷贝所有的属性,并拷贝属性指向的动态分配的内存。当对象和它所引用的对象一起拷贝时即发生深拷贝。深拷贝相比于浅拷贝速度较慢并且花销较大。

将对象及值复制过来，两个对象修改其中任意的值另一个值不会改变。

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

原型模式其实就是一个对象在创建另一个可定制的对象，而且不需要指定任何创建的细节。Java提供了Coneable接口，其中有一个唯一方法Clone()，实现这个接口就可以完成原型模式了。

实例说明
浅拷贝案例
声明 User 实体类，需要实现 Cloneable 接口，并覆写 clone() 方法。

User 属性包括基础数据类型和引用数据类型，方便演示

 
 
 
 
      
  
  
  
  1. package com.niuh.designpattern.prototype; 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3. /** 
    4.   
  
  
  
  4.  * 用户信息 
    5.   
  
  
  
  5.  */ 
    6.   
  
  
  
  6. public class User implements Cloneable { 
    7.   
  
  
  
  7.  
    8.   
  
  
  
  8.     // 基础数据类型 
    9.   
  
  
  
  9.     private int id; 
    10.   
  
  
  
  10.     private String name; 
    11.   
  
  
  
  11.     private String sex; 
    12.   
  
  
  
  12.     private String pwd; 
    13.   
  
  
  
  13.  
    14.   
  
  
  
  14.     // 引用数据类型 
    15.   
  
  
  
  15.     private BaseInfo baseInfo; 
    16.   
  
  
  
  16.  
    17.   
  
  
  
  17.     public User(int id, String name, String sex, String pwd, BaseInfo baseInfo) { 
    18.   
  
  
  
  18.         this.id = id; 
    19.   
  
  
  
  19.         this.name = name; 
    20.   
  
  
  
  20.         this.sex = sex; 
    21.   
  
  
  
  21.         this.pwd = pwd; 
    22.   
  
  
  
  22.         this.baseInfo = baseInfo; 
    23.   
  
  
  
  23.     } 
    24.   
  
  
  
  24.  
    25.   
  
  
  
  25.     public int getId() { 
    26.   
  
  
  
  26.         return id; 
    27.   
  
  
  
  27.     } 
    28.   
  
  
  
  28.  
    29.   
  
  
  
  29.     public void setId(int id) { 
    30.   
  
  
  
  30.         this.id = id; 
    31.   
  
  
  
  31.     } 
    32.   
  
  
  
  32.  
    33.   
  
  
  
  33.     public String getName() { 
    34.   
  
  
  
  34.         return name; 
    35.   
  
  
  
  35.     } 
    36.   
  
  
  
  36.  
    37.   
  
  
  
  37.     public void setName(String name) { 
    38.   
  
  
  
  38.         this.name = name; 
    39.   
  
  
  
  39.     } 
    40.   
  
  
  
  40.  
    41.   
  
  
  
  41.     public String getSex() { 
    42.   
  
  
  
  42.         return sex; 
    43.   
  
  
  
  43.     } 
    44.   
  
  
  
  44.  
    45.   
  
  
  
  45.     public void setSex(String sex) { 
    46.   
  
  
  
  46.         this.sex = sex; 
    47.   
  
  
  
  47.     } 
    48.   
  
  
  
  48.  
    49.   
  
  
  
  49.     public String getPwd() { 
    50.   
  
  
  
  50.         return pwd; 
    51.   
  
  
  
  51.     } 
    52.   
  
  
  
  52.  
    53.   
  
  
  
  53.     public void setPwd(String pwd) { 
    54.   
  
  
  
  54.         this.pwd = pwd; 
    55.   
  
  
  
  55.     } 
    56.   
  
  
  
  56.  
    57.   
  
  
  
  57.     public BaseInfo getBaseInfo() { 
    58.   
  
  
  
  58.         return baseInfo; 
    59.   
  
  
  
  59.     } 
    60.   
  
  
  
  60.  
    61.   
  
  
  
  61.     public void setBaseInfo(BaseInfo baseInfo) { 
    62.   
  
  
  
  62.         this.baseInfo = baseInfo; 
    63.   
  
  
  
  63.     } 
    64.   
  
  
  
  64.  
    65.   
  
  
  
  65.     @Override 
    66.   
  
  
  
  66.     public String toString() { 
    67.   
  
  
  
  67.         return "hashCode: " + super.hashCode() + ", User{" + 
    68.   
  
  
  
  68.                 "id=" + id + 
    69.   
  
  
  
  69.                 ", name='" + name + '\'' + 
    70.   
  
  
  
  70.                 ", sex='" + sex + '\'' + 
    71.   
  
  
  
  71.                 ", pwd='" + pwd + '\'' + 
    72.   
  
  
  
  72.                 ", baseInfo=" + baseInfo + 
    73.   
  
  
  
  73.                 '}'; 
    74.   
  
  
  
  74.     } 
    75.   
  
  
  
  75.  
    76.   
  
  
  
  76.     @Override 
    77.   
  
  
  
  77.     protected User clone() throws CloneNotSupportedException { 
    78.   
  
  
  
  78.         return (User) super.clone(); 
    79.   
  
  
  
  79.     } 
    80.   
  
  
  
  80. } 
    81.  
 
 


 
 
 
 
      
  
  
  
  1. package com.niuh.designpattern.prototype; 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3. import java.util.Date; 
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5. /** 
    6.   
  
  
  
  6.  * 基础类 
    7.   
  
  
  
  7.  */ 
    8.   
  
  
  
  8. public class BaseInfo { 
    9.   
  
  
  
  9.  
    10.   
  
  
  
  10.     private String desc; 
    11.   
  
  
  
  11.  
    12.   
  
  
  
  12.     // ....... 
    13.   
  
  
  
  13.  
    14.   
  
  
  
  14.  
    15.   
  
  
  
  15.     public BaseInfo(String desc) { 
    16.   
  
  
  
  16.         this.desc = desc; 
    17.   
  
  
  
  17.     } 
    18.   
  
  
  
  18.  
    19.   
  
  
  
  19.     public String getDesc() { 
    20.   
  
  
  
  20.         return desc; 
    21.   
  
  
  
  21.     } 
    22.   
  
  
  
  22.  
    23.   
  
  
  
  23.     public void setDesc(String desc) { 
    24.   
  
  
  
  24.         this.desc = desc; 
    25.   
  
  
  
  25.     } 
    26.   
  
  
  
  26.  
    27.   
  
  
  
  27.     @Override 
    28.   
  
  
  
  28.     public String toString() { 
    29.   
  
  
  
  29.         return "BaseInfo{" + 
    30.   
  
  
  
  30.                 "desc=" + desc + 
    31.   
  
  
  
  31.                 '}'; 
    32.   
  
  
  
  32.     } 
    33.   
  
  
  
  33. } 
    34.  
 
 


 
 
 
 
      
  
  
  
  1. package com.niuh.designpattern.prototype; 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3.  
    4.   
  
  
  
  4. /** 
    5.   
  
  
  
  5.  * 原型设计模式 
    6.   
  
  
  
  6.  */ 
    7.   
  
  
  
  7. public class PrototypePattern { 
    8.   
  
  
  
  8.     public static void main(String[] args) throws CloneNotSupportedException { 
    9.   
  
  
  
  9.  
    10.   
  
  
  
  10.         BaseInfo baseInfo = new BaseInfo("张三"); 
    11.   
  
  
  
  11.  
    12.   
  
  
  
  12.         User user1 = new User(1, "张三", "男", "123456", baseInfo); 
    13.   
  
  
  
  13.  
    14.   
  
  
  
  14.         // new User  ...... 
    15.   
  
  
  
  15.  
    16.   
  
  
  
  16.         // 克隆机制 
    17.   
  
  
  
  17.         User user2 = user1.clone(); 
    18.   
  
  
  
  18.         user2.setId(2); 
    19.   
  
  
  
  19.         user2.setName("李四"); 
    20.   
  
  
  
  20.         BaseInfo baseInfo1 = user2.getBaseInfo(); 
    21.   
  
  
  
  21.         baseInfo1.setDesc("李四"); 
    22.   
  
  
  
  22.  
    23.   
  
  
  
  23.  
    24.   
  
  
  
  24.         System.out.println(user1); 
    25.   
  
  
  
  25.         System.out.println(user2); 
    26.   
  
  
  
  26.  
    27.   
  
  
  
  27.     } 
    28.   
  
  
  
  28. } 
    29.

输出结果如下：

由输出的结果可见，通过 user1.clone() 拷贝对象后得到的 user2，和 user1 是两个不同的对象，HashCode 值不一样。user1 和 user2 的基础数据类型的修改互不影响，而引用类型 baseInfo 修改后是会有影响的。

深拷贝案例
通过上面的例子可以看到，浅拷贝会带来数据安全方面的隐患，例如我们只是想修改了 user2 的 baseInfo，但是 user1 的 baseInfo 也被修改了，因为它们都是指向的同一个地址。所以，此种情况下，我们需要用到深拷贝。

深拷贝，在拷贝引用类型成员变量时，为引用类型的数据成员另辟了一个独立的内存空间，实现真正内容上的拷贝。

对于 User 的引用类型的成员变量 BaseInfo ，需要实现 Cloneable 并重写 clone() 方法。

 
 
 
 
      
  
  
  
  1. package com.niuh.designpattern.prototype; 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3. import java.util.Date; 
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5. /** 
    6.   
  
  
  
  6.  * 基础类 
    7.   
  
  
  
  7.  */ 
    8.   
  
  
  
  8. public class BaseInfo implements Cloneable { 
    9.   
  
  
  
  9.  
    10.   
  
  
  
  10.     private String desc; 
    11.   
  
  
  
  11.  
    12.   
  
  
  
  12.     // ....... 
    13.   
  
  
  
  13.  
    14.   
  
  
  
  14.  
    15.   
  
  
  
  15.     public BaseInfo(String desc) { 
    16.   
  
  
  
  16.         this.desc = desc; 
    17.   
  
  
  
  17.     } 
    18.   
  
  
  
  18.  
    19.   
  
  
  
  19.     public String getDesc() { 
    20.   
  
  
  
  20.         return desc; 
    21.   
  
  
  
  21.     } 
    22.   
  
  
  
  22.  
    23.   
  
  
  
  23.     public void setDesc(String desc) { 
    24.   
  
  
  
  24.         this.desc = desc; 
    25.   
  
  
  
  25.     } 
    26.   
  
  
  
  26.  
    27.   
  
  
  
  27.     @Override 
    28.   
  
  
  
  28.     public String toString() { 
    29.   
  
  
  
  29.         return "BaseInfo{" + 
    30.   
  
  
  
  30.                 "desc=" + desc + 
    31.   
  
  
  
  31.                 '}'; 
    32.   
  
  
  
  32.     } 
    33.   
  
  
  
  33.  
    34.   
  
  
  
  34.     @Override 
    35.   
  
  
  
  35.     protected BaseInfo clone() throws CloneNotSupportedException { 
    36.   
  
  
  
  36.         //BaseInfo 如果也有引用类型的成员属性，也应该和 User 类一样实现 
    37.   
  
  
  
  37.         return (BaseInfo) super.clone(); 
    38.   
  
  
  
  38.     } 
    39.   
  
  
  
  39. } 
    40.

在 User 的 clone() 方法中，需要拿到拷贝自己后产生的新的对象，然后对新的对象的引用类型再调用拷贝操作，实现对引用类型成员变量的深拷贝。

 
 
 
 
      
  
  
  
  1. package com.niuh.designpattern.prototype; 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3. /** 
    4.   
  
  
  
  4.  * 用户信息 
    5.   
  
  
  
  5.  */ 
    6.   
  
  
  
  6. public class User implements Cloneable { 
    7.   
  
  
  
  7.  
    8.   
  
  
  
  8.     // 基础数据类型 
    9.   
  
  
  
  9.     private int id; 
    10.   
  
  
  
  10.     private String name; 
    11.   
  
  
  
  11.     private String sex; 
    12.   
  
  
  
  12.     private String pwd; 
    13.   
  
  
  
  13.  
    14.   
  
  
  
  14.     // 引用数据类型 
    15.   
  
  
  
  15.     private BaseInfo baseInfo; 
    16.   
  
  
  
  16.  
    17.   
  
  
  
  17.     public User(int id, String name, String sex, String pwd, BaseInfo baseInfo) { 
    18.   
  
  
  
  18.         this.id = id; 
    19.   
  
  
  
  19.         this.name = name; 
    20.   
  
  
  
  20.         this.sex = sex; 
    21.   
  
  
  
  21.         this.pwd = pwd; 
    22.   
  
  
  
  22.         this.baseInfo = baseInfo; 
    23.   
  
  
  
  23.     } 
    24.   
  
  
  
  24.  
    25.   
  
  
  
  25.     public int getId() { 
    26.   
  
  
  
  26.         return id; 
    27.   
  
  
  
  27.     } 
    28.   
  
  
  
  28.  
    29.   
  
  
  
  29.     public void setId(int id) { 
    30.   
  
  
  
  30.         this.id = id; 
    31.   
  
  
  
  31.     } 
    32.   
  
  
  
  32.  
    33.   
  
  
  
  33.     public String getName() { 
    34.   
  
  
  
  34.         return name; 
    35.   
  
  
  
  35.     } 
    36.   
  
  
  
  36.  
    37.   
  
  
  
  37.     public void setName(String name) { 
    38.   
  
  
  
  38.         this.name = name; 
    39.   
  
  
  
  39.     } 
    40.   
  
  
  
  40.  
    41.   
  
  
  
  41.     public String getSex() { 
    42.   
  
  
  
  42.         return sex; 
    43.   
  
  
  
  43.     } 
    44.   
  
  
  
  44.  
    45.   
  
  
  
  45.     public void setSex(String sex) { 
    46.   
  
  
  
  46.         this.sex = sex; 
    47.   
  
  
  
  47.     } 
    48.   
  
  
  
  48.  
    49.   
  
  
  
  49.     public String getPwd() { 
    50.   
  
  
  
  50.         return pwd; 
    51.   
  
  
  
  51.     } 
    52.   
  
  
  
  52.  
    53.   
  
  
  
  53.     public void setPwd(String pwd) { 
    54.   
  
  
  
  54.         this.pwd = pwd; 
    55.   
  
  
  
  55.     } 
    56.   
  
  
  
  56.  
    57.   
  
  
  
  57.     public BaseInfo getBaseInfo() { 
    58.   
  
  
  
  58.         return baseInfo; 
    59.   
  
  
  
  59.     } 
    60.   
  
  
  
  60.  
    61.   
  
  
  
  61.     public void setBaseInfo(BaseInfo baseInfo) { 
    62.   
  
  
  
  62.         this.baseInfo = baseInfo; 
    63.   
  
  
  
  63.     } 
    64.   
  
  
  
  64.  
    65.   
  
  
  
  65.     @Override 
    66.   
  
  
  
  66.     public String toString() { 
    67.   
  
  
  
  67.         return "hashCode: " + super.hashCode() + ", User{" + 
    68.   
  
  
  
  68.                 "id=" + id + 
    69.   
  
  
  
  69.                 ", name='" + name + '\'' + 
    70.   
  
  
  
  70.                 ", sex='" + sex + '\'' + 
    71.   
  
  
  
  71.                 ", pwd='" + pwd + '\'' + 
    72.   
  
  
  
  72.                 ", baseInfo=" + baseInfo + 
    73.   
  
  
  
  73.                 '}'; 
    74.   
  
  
  
  74.     } 
    75.   
  
  
  
  75.  
    76.   
  
  
  
  76.     @Override 
    77.   
  
  
  
  77.     protected User clone() throws CloneNotSupportedException { 
    78.   
  
  
  
  78.         // 深拷贝 
    79.   
  
  
  
  79.         User user = (User) super.clone(); 
    80.   
  
  
  
  80.         user.baseInfo = baseInfo.clone(); 
    81.   
  
  
  
  81.         return user; 
    82.   
  
  
  
  82.     } 
    83.   
  
  
  
  83. } 
    84.

与上面的使用方式一样，输出结果如下：

由输出结果可见，深拷贝后，不管是基础数据类型还是引用类型的成员变量，修改其值都不会相互造成影响。

序列化机制实现深拷贝
需要在 User 类实现 Serializable，成员类型（BaseInfo）也需要实现 Serializable 接口。

 
 
 
 
      
  
  
  
  1. package com.niuh.designpattern.prototype; 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3. import java.io.ByteArrayInputStream; 
    4.   
  
  
  
  4. import java.io.ByteArrayOutputStream; 
    5.   
  
  
  
  5. import java.io.IOException; 
    6.   
  
  
  
  6. import java.io.ObjectInputStream; 
    7.   
  
  
  
  7. import java.io.ObjectOutputStream; 
    8.   
  
  
  
  8. import java.io.Serializable; 
    9.   
  
  
  
  9.  
    10.   
  
  
  
  10. /** 
    11.   
  
  
  
  11.  * 用户信息 
    12.   
  
  
  
  12.  */ 
    13.   
  
  
  
  13. public class User implements Cloneable , Serializable { 
    14.   
  
  
  
  14.  
    15.   
  
  
  
  15.     // 基础数据类型 
    16.   
  
  
  
  16.     private int id; 
    17.   
  
  
  
  17.     private String name; 
    18.   
  
  
  
  18.     private String sex; 
    19.   
  
  
  
  19.     private String pwd; 
    20.   
  
  
  
  20.  
    21.   
  
  
  
  21.     // 引用数据类型 
    22.   
  
  
  
  22.     private BaseInfo baseInfo; 
    23.   
  
  
  
  23.  
    24.   
  
  
  
  24.     public User(int id, String name, String sex, String pwd, BaseInfo baseInfo) { 
    25.   
  
  
  
  25.         this.id = id; 
    26.   
  
  
  
  26.         this.name = name; 
    27.   
  
  
  
  27.         this.sex = sex; 
    28.   
  
  
  
  28.         this.pwd = pwd; 
    29.   
  
  
  
  29.         this.baseInfo = baseInfo; 
    30.   
  
  
  
  30.     } 
    31.   
  
  
  
  31.  
    32.   
  
  
  
  32.     public int getId() { 
    33.   
  
  
  
  33.         return id; 
    34.   
  
  
  
  34.     } 
    35.   
  
  
  
  35.  
    36.   
  
  
  
  36.     public void setId(int id) { 
    37.   
  
  
  
  37.         this.id = id; 
    38.   
  
  
  
  38.     } 
    39.   
  
  
  
  39.  
    40.   
  
  
  
  40.     public String getName() { 
    41.   
  
  
  
  41.         return name; 
    42.   
  
  
  
  42.     } 
    43.   
  
  
  
  43.  
    44.   
  
  
  
  44.     public void setName(String name) { 
    45.   
  
  
  
  45.         this.name = name; 
    46.   
  
  
  
  46.     } 
    47.   
  
  
  
  47.  
    48.   
  
  
  
  48.     public String getSex() { 
    49.   
  
  
  
  49.         return sex; 
    50.   
  
  
  
  50.     } 
    51.   
  
  
  
  51.  
    52.   
  
  
  
  52.     public void setSex(String sex) { 
    53.   
  
  
  
  53.         this.sex = sex; 
    54.   
  
  
  
  54.     } 
    55.   
  
  
  
  55.  
    56.   
  
  
  
  56.     public String getPwd() { 
    57.   
  
  
  
  57.         return pwd; 
    58.   
  
  
  
  58.     } 
    59.   
  
  
  
  59.  
    60.   
  
  
  
  60.     public void setPwd(String pwd) { 
    61.   
  
  
  
  61.         this.pwd = pwd; 
    62.   
  
  
  
  62.     } 
    63.   
  
  
  
  63.  
    64.   
  
  
  
  64.     public BaseInfo getBaseInfo() { 
    65.   
  
  
  
  65.         return baseInfo; 
    66.   
  
  
  
  66.     } 
    67.   
  
  
  
  67.  
    68.   
  
  
  
  68.     public void setBaseInfo(BaseInfo baseInfo) { 
    69.   
  
  
  
  69.         this.baseInfo = baseInfo; 
    70.   
  
  
  
  70.     } 
    71.   
  
  
  
  71.  
    72.   
  
  
  
  72.     @Override 
    73.   
  
  
  
  73.     public String toString() { 
    74.   
  
  
  
  74.         return "hashCode: " + super.hashCode() + ", User{" + 
    75.   
  
  
  
  75.                 "id=" + id + 
    76.   
  
  
  
  76.                 ", name='" + name + '\'' + 
    77.   
  
  
  
  77.                 ", sex='" + sex + '\'' + 
    78.   
  
  
  
  78.                 ", pwd='" + pwd + '\'' + 
    79.   
  
  
  
  79.                 ", baseInfo=" + baseInfo + 
    80.   
  
  
  
  80.                 '}'; 
    81.   
  
  
  
  81.     } 
    82.   
  
  
  
  82.  
    83.   
  
  
  
  83.     @Override 
    84.   
  
  
  
  84.     protected User clone() throws CloneNotSupportedException { 
    85.   
  
  
  
  85.         // 深拷贝 
    86.   
  
  
  
  86.         // User user = (User) super.clone(); 
    87.   
  
  
  
  87.         // user.baseInfo = baseInfo.clone(); 
    88.   
  
  
  
  88.         // return user; 
    89.   
  
  
  
  89.  
    90.   
  
  
  
  90.  
    91.   
  
  
  
  91.         ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(); 
    92.   
  
  
  
  92.  
    93.   
  
  
  
  93.         try (ObjectOutputStream oos = new ObjectOutputStream(byteArrayOutputStream)) { 
    94.   
  
  
  
  94.  
    95.   
  
  
  
  95.             oos.writeObject(this); 
    96.   
  
  
  
  96.  
    97.   
  
  
  
  97.         } catch (IOException e) { 
    98.   
  
  
  
  98.             e.printStackTrace(); 
    99.   
  
  
  
  99.         } 
    100.   
  
  
  
  100.  
    101.   
  
  
  
  101.         ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray()); 
    102.   
  
  
  
  102.  
    103.   
  
  
  
  103.         try (ObjectInputStream ois = new ObjectInputStream(byteArrayInputStream)) { 
    104.   
  
  
  
  104.             try { 
    105.   
  
  
  
  105.                 User user = (User) ois.readObject(); 
    106.   
  
  
  
  106.                 return user; 
    107.   
  
  
  
  107.             } catch (ClassNotFoundException e) { 
    108.   
  
  
  
  108.                 e.printStackTrace(); 
    109.   
  
  
  
  109.             } 
    110.   
  
  
  
  110.         } catch (IOException e) { 
    111.   
  
  
  
  111.             e.printStackTrace(); 
    112.   
  
  
  
  112.         } 
    113.   
  
  
  
  113.         return null; 
    114.   
  
  
  
  114.     } 
    115.   
  
  
  
  115. } 
    116.

这个时候并没有使用Java深拷贝，改变成员属性Baseinfo，也能保存对象的独立性。

通过序列化机制来完成深拷贝不推荐使用，因为序列化操作是CPU密集型，解析流是比较消耗性能，速度会比较慢

优点

  • 可以不耦合具体类的情况下克隆对象
  • 避免重复的初始化代码
  • 更方便的构建复杂对象

缺点

  • 适用性不是很广。
  • 每一个类必须配备一个克隆方法。
  • 配备克隆方法需要对类的功能进行通盘考虑，这对于全新的类不是很难，但对于已有的类不一定很容易，特别当一个类引用不支持串行化的间接对象，或者引用含有循环结构的时候。

应用场景
当代码不应该依赖于需要复制的对象的具体类时，请使用Prototype模式。

  • 某些结构复杂的对象的创建工作；由于需求的变化，这些对象经常面临着剧烈的变化，但是他们却拥有比较稳定一致的接口；
  • 一般在初始化的信息不发生变化的情况下，克隆是最好的方法。

源码中的应用

 
 
 
 
      
  
  
  
  1. #Spring  
    2.   
  
  
  
  2. org.springframework.beans.factory.support.AbstractBeanDefinition 
    3.   
  
  
  
  3. #JDK 
    4.   
  
  
  
  4. java.util.Arrays 
    5.   
  
  
  
  5. java.util.ArrayList 
    6.   
  
  
  
  6. ...... 
    7.

ArrayList中的使用
ArrayList也有clone()方法，如下

  • 返回一个Object对象，所以在使用此方法的时候要强制转换。
  • ArrayList的本质是维护了一个Object的数组，所以克隆也是通过数组的复制实现的，属于浅复制。
 
 
 
 
      
  
  
  
  1. @Override  
    2.   
  
  
  
  2.   public Object clone() { 
    3.   
  
  
  
  3.     try { 
    4.   
  
  
  
  4.         ArrayList result = (ArrayList) super.clone(); 
    5.   
  
  
  
  5.         result.array = array.clone(); 
    6.   
  
  
  
  6.         return result; 
    7.   
  
  
  
  7.     } catch (CloneNotSupportedException e) { 
    8.   
  
  
  
  8.        throw new AssertionError(); 
    9.   
  
  
  
  9.     } 
    10.   
  
  
  
  10. } 
    11.

ArrayList的Clone浅复制的巧妙使用
当你需要使用remove方法移除掉集合中的对象，而非要修改集合中的对象的时候，可以选择使用。

 
 
 
 
      
  
  
  
  1. //添加两个元素 
    2.   
  
  
  
  2. Student stJack=new Student("Jack", 13); 
    3.   
  
  
  
  3. Student stTom=new Student("Tom", 15); 
    4.   
  
  
  
  4. list.add(stJack); 
    5.   
  
  
  
  5. list.add(stTom); 
    6.   
  
  
  
  6.  
    7.   
  
  
  
  7. //克隆 
    8.   
  
  
  
  8. ArrayList listCopy=(ArrayList) list.clone(); 
    9.   
  
  
  
  9.  
    10.   
  
  
  
  10. //移除且不修改 
    11.   
  
  
  
  11. listCopy.remove(1); 
    12.   
  
  
  
  12. System.out.println(list); 
    13.   
  
  
  
  13. System.out.println(listCopy); 
    14.

移除且不修改集合中的元素，只是在List内部的数组中移除了指向元素的地址，可以放心的使用clone。

PS：以上代码提交在 Github ：https://github.com/Niuh-Study/niuh-designpatterns.git

当前文章：设计模式系列—原型模式
文章源于：http://www.36103.cn/qtweb/news31/38131.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

网站营销知识

同城分类信息

网站排名优化　　 　混凝土搅拌罐车　　 　网站空间　　 　安娜尚美　　 　成都做网站　　 　贵阳托管服务器　　 　bgp机房托管　　 　贵安服务器托管　　 　成都网站推广　　 　医药医疗网站建设方案　　 　成都网站制作　　 　全网营销推广　　 　成都高电机柜租用　　 　眉山电信机房　　 　成都包装设计公司　　 　背发光字　　 　联通服务器托管　　 　成都网站推广公司　　 　成都网站维护公司　　 　交互设计