自拍偷在线精品自拍偷,亚洲欧美中文日韩v在线观看不卡

設計模式系列—原型模式

作者：一角錢技術
開發(fā) 前端
本篇和大家一起來學習原型模式，在學習原型模式之前我們需要先認識下淺拷貝和深拷貝這兩個概念。

 前言

  • 23種設計模式速記
  • 單例（singleton）模式
  • 工廠方法（factory method）模式
  • 抽象工廠（abstract factory）模式
  • 建造者/構建器（builder）模式

23種設計模式快速記憶的請看上面第一篇，本篇和大家一起來學習原型模式，在學習原型模式之前我們需要先認識下淺拷貝和深拷貝這兩個概念。

淺拷貝和深拷貝
淺拷貝
淺拷貝是按位拷貝對象，它會創(chuàng)建一個新對象，這個對象有著原始對象屬性值的一份精確拷貝。如果屬性是基本類型，拷貝的就是基本類型的值；如果屬性是內存地址（引用類型），拷貝的就是內存地址 ，因此如果其中一個對象改變了這個地址，就會影響到另一個對象。

復制了對象的引用地址，兩個對象指向同一個內存地址，所以修改其中任意的值，另一個值都會隨之變化。

深拷貝
深拷貝會拷貝所有的屬性,并拷貝屬性指向的動態(tài)分配的內存。當對象和它所引用的對象一起拷貝時即發(fā)生深拷貝。深拷貝相比于淺拷貝速度較慢并且花銷較大。

將對象及值復制過來，兩個對象修改其中任意的值另一個值不會改變。

模式定義
用原型實例指定創(chuàng)建對象的種類，并且通過拷貝這些原型創(chuàng)建新的對象。

原型模式其實就是一個對象在創(chuàng)建另一個可定制的對象，而且不需要指定任何創(chuàng)建的細節(jié)。Java提供了Coneable接口，其中有一個唯一方法Clone()，實現(xiàn)這個接口就可以完成原型模式了。

實例說明
淺拷貝案例
聲明 User 實體類，需要實現(xiàn) Cloneable 接口，并覆寫 clone() 方法。

User 屬性包括基礎數(shù)據(jù)類型和引用數(shù)據(jù)類型，方便演示

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

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

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

輸出結果如下：

由輸出的結果可見，通過 user1.clone() 拷貝對象后得到的 user2，和 user1 是兩個不同的對象，HashCode 值不一樣。user1 和 user2 的基礎數(shù)據(jù)類型的修改互不影響，而引用類型 baseInfo 修改后是會有影響的。

深拷貝案例
通過上面的例子可以看到，淺拷貝會帶來數(shù)據(jù)安全方面的隱患，例如我們只是想修改了 user2 的 baseInfo，但是 user1 的 baseInfo 也被修改了，因為它們都是指向的同一個地址。所以，此種情況下，我們需要用到深拷貝。

深拷貝，在拷貝引用類型成員變量時，為引用類型的數(shù)據(jù)成員另辟了一個獨立的內存空間，實現(xiàn)真正內容上的拷貝。

對于 User 的引用類型的成員變量 BaseInfo ，需要實現(xiàn) Cloneable 并重寫 clone() 方法。

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

在 User 的 clone() 方法中，需要拿到拷貝自己后產生的新的對象，然后對新的對象的引用類型再調用拷貝操作，實現(xiàn)對引用類型成員變量的深拷貝。

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

與上面的使用方式一樣，輸出結果如下：

由輸出結果可見，深拷貝后，不管是基礎數(shù)據(jù)類型還是引用類型的成員變量，修改其值都不會相互造成影響。

序列化機制實現(xiàn)深拷貝
需要在 User 類實現(xiàn) Serializable，成員類型（BaseInfo）也需要實現(xiàn) Serializable 接口。

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

這個時候并沒有使用Java深拷貝，改變成員屬性Baseinfo，也能保存對象的獨立性。

通過序列化機制來完成深拷貝不推薦使用，因為序列化操作是CPU密集型，解析流是比較消耗性能，速度會比較慢

優(yōu)點

  • 可以不耦合具體類的情況下克隆對象
  • 避免重復的初始化代碼
  • 更方便的構建復雜對象

缺點

  • 適用性不是很廣。
  • 每一個類必須配備一個克隆方法。
  • 配備克隆方法需要對類的功能進行通盤考慮，這對于全新的類不是很難，但對于已有的類不一定很容易，特別當一個類引用不支持串行化的間接對象，或者引用含有循環(huán)結構的時候。

應用場景
當代碼不應該依賴于需要復制的對象的具體類時，請使用Prototype模式。

  • 某些結構復雜的對象的創(chuàng)建工作；由于需求的變化，這些對象經常面臨著劇烈的變化，但是他們卻擁有比較穩(wěn)定一致的接口；
  • 一般在初始化的信息不發(fā)生變化的情況下，克隆是最好的方法。

源碼中的應用

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

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

  • 返回一個Object對象，所以在使用此方法的時候要強制轉換。
  • ArrayList的本質是維護了一個Object的數(shù)組，所以克隆也是通過數(shù)組的復制實現(xiàn)的，屬于淺復制。
  1. @Override  
  2.   public Object clone() { 
  3.     try { 
  4.         ArrayList<?> result = (ArrayList<?>) super.clone(); 
  5.         result.array = array.clone(); 
  6.         return result; 
  7.     } catch (CloneNotSupportedException e) { 
  8.        throw new AssertionError(); 
  9.     } 
  10. } 

ArrayList的Clone淺復制的巧妙使用
當你需要使用remove方法移除掉集合中的對象，而非要修改集合中的對象的時候，可以選擇使用。

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

移除且不修改集合中的元素，只是在List內部的數(shù)組中移除了指向元素的地址，可以放心的使用clone。

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

責任編輯：姜華 來源： 今日頭條
原型模式
相關推薦

2021-10-28 19:09:09

模式原型Java

2013-11-26 17:00:08

Android設計模式

2021-05-18 08:52:31

Prototype 原型模式設計模式

2022-09-21 08:47:05

項目多線程對象

2023-08-08 20:13:36

設計模式原型模式

2021-06-07 09:51:22

原型模式序列化

2020-06-08 08:04:49

設計模式結構型接口

2022-01-12 13:33:25

工廠模式設計

2020-10-23 09:40:26

設計模式

2020-11-03 13:05:18

命令模式

2020-11-04 08:54:54

狀態(tài)模式

2015-06-08 09:05:10

Java原型模式

2021-06-09 08:53:34

設計模式策略模式工廠模式

2020-10-19 09:28:00

抽象工廠模式

2021-09-29 13:53:17

抽象工廠模式

2022-01-14 09:22:22

設計模式橋接

2013-11-26 15:48:53

Android設計模式SDK

2021-03-02 08:50:31

設計單例模式

2020-11-09 08:20:33

解釋器模式

2020-10-20 13:33:00

建造者模式
點贊
收藏

51CTO技術棧公眾號