2. 程式人生 > >工廠模式簡介和應用場景

工廠模式簡介和應用場景

阿新 • • 發佈：2019-02-12

結合簡單示例和UML圖，講解工廠模式簡單原理。

一、引子

話說十年前，有一個爆發戶，他家有三輛汽車（Benz（賓士）、Bmw（寶馬）、Audi（奧迪）），還僱了司機為他開車。不過，爆發戶坐車時總是這樣：上Benz車後跟司機說“開賓士車！”，坐上Bmw後他說“開寶馬車！”，坐上 Audi後他說“開奧迪車！”。
你一定說：這人有病！直接說開車不就行了？！而當把這個爆發戶的行為放到我們程式語言中來，我們發現C語言一直是通過這種方式來坐車的！
幸運的是這種有病的現象在OO語言中可以避免了。下面以Java語言為基礎來引入我們本文的主題：工廠模式！

二、簡介

工廠模式主要是為建立物件提供了介面。工廠模式按照《Java與模式》中的提法分為三類：
1. 簡單工廠模式(Simple Factory)
2. 工廠方法模式(Factory Method)
3. 抽象工廠模式(Abstract Factory)
這三種模式從上到下逐步抽象，並且更具一般性。還有一種分類法，就是將簡單工廠模式看為工廠方法模式的一種特例，兩個歸為一類。兩者皆可，這本為使用《Java與模式》的分類方法。
在什麼樣的情況下我們應該記得使用工廠模式呢？大體有兩點：
1.在編碼時不能預見需要建立哪種類的例項。
2.系統不應依賴於產品類例項如何被建立、組合和表達的細節
工廠模式能給我們的OOD、OOP帶來哪些好處呢？？

三、簡單工廠模式

這個模式本身很簡單而且使用在業務較簡單的情況下。一般用於小專案或者具體產品很少擴充套件的情況（這樣工廠類才不用經常更改）。
它由三種角色組成：
工廠類角色：這是本模式的核心，含有一定的商業邏輯和判斷邏輯，根據邏輯不同，產生具體的工廠產品。如例子中的Driver類。
抽象產品角色：它一般是具體產品繼承的父類或者實現的介面。由介面或者抽象類來實現。如例中的Car介面。
具體產品角色：工廠類所建立的物件就是此角色的例項。在java中由一個具體類實現，如例子中的Benz、Bmw類。


來用類圖來清晰的表示下的它們之間的關係：



 

下面就來給那個暴發戶治病：在使用了簡單工廠模式後，現在暴發戶只需要坐在車裡對司機說句：“開車”就可以了。來看看怎麼用程式碼實現的：（為方便起見，所有的類放在一個檔案中，故有一個類被宣告為public）

Java程式碼  收藏程式碼

  1. //抽象產品  
  2. abstract class Car{  
  3.     private String name;  
  4.     public abstract void drive();  
  5.     public String getName() {  
  6.         return name;  
  7.     }  
  8.     public void setName(String name) {  
  9.         this.name = name;  
  10.     }  
  11. }  
  12. //具體產品  
  13. class Benz extends Car{  
  14.     public void drive(){  
  15.         System.out.println(this.getName()+"----go-----------------------");  
  16.     }  
  17. }  
  18. class Bmw extends Car{  
  19.     public void drive(){  
  20.         System.out.println(this.getName()+"----go-----------------------");  
  21.     }  
  22. }  
  23. //簡單工廠  
  24. class Driver{  
  25.     public static Car createCar(String car){  
  26.         Car c = null;  
  27.         if("Benz".equalsIgnoreCase(car))  
  28.             c = new Benz();  
  29.         else if("Bmw".equalsIgnoreCase(car))  
  30.             c = new Bmw();  
  31.         return c;  
  32.     }  
  33. }  
  34. //老闆  
  35. public class BossSimplyFactory {  
  36.     public static void main(String[] args) throws IOException {  
  37.         //老闆告訴司機我今天坐賓士  
  38.         Car car = Driver.createCar("benz");  
  39.         car.setName("benz");  
  40.          //司機開著賓士出發  
  41.         car.drive();  
  42.     }  
  43. <span style="font-family: courier new,courier;">}</span>  

如果老闆要坐奧迪，同理。

這便是簡單工廠模式了。那麼它帶了了什麼好處呢？
首先，符合現實中的情況；而且客戶端免除了直接建立產品物件的責任，而僅僅負責“消費”產品（正如暴發戶所為）。
下面我們從開閉原則上來分析下簡單工廠模式。當暴發戶增加了一輛車的時候，只要符合抽象產品制定的合同，那麼只要通知工廠類知道就可以被客戶使用了。（即建立一個新的車類，繼承抽象產品Car）那麼 對於產品部分來說，它是符合開閉原則的——對擴充套件開放、對修改關閉；但是工廠類不太理想，因為每增加一輛車，都要在工廠類中增加相應的商業邏輯和判 斷邏輯，這顯自然是違背開閉原則的。

而在實際應用中，很可能產品是一個多層次的樹狀結構。由於簡單工廠模式中只有一個工廠類來對應這些產品，所以這可能會把我們的上帝類壞了。
正如我前面提到的簡單工廠模式適用於業務簡單的情況下或者具體產品很少增加的情況。而對於複雜的業務環境可能不太適應了。這就應該由工廠方法模式來出場了！！

四、工廠方法模式
抽象工廠角色： 這是工廠方法模式的核心，它與應用程式無關。是具體工廠角色必須實現的介面或者必須繼承的父類。在java中它由抽象類或者介面來實現。
具體工廠角色：它含有和具體業務邏輯有關的程式碼。由應用程式呼叫以建立對應的具體產品的物件。在java中它由具體的類來實現。
抽象產品角色：它是具體產品繼承的父類或者是實現的介面。在java中一般有抽象類或者介面來實現。
具體產品角色：具體工廠角色所建立的物件就是此角色的例項。在java中由具體的類來實現。
來用類圖來清晰的表示下的它們之間的關係：

 

 

話說暴發戶生意越做越大，自己的愛車也越來越多。這可苦了那位司機師傅了，什麼車它都要記得，維護，都要經過他來使用！於是暴發戶同情他說：我給你分配幾個人手，你只管管好他們就行了！於是工廠方法模式的管理出現了。程式碼如下：

Java程式碼  收藏程式碼

  1. //抽象產品  
  2. abstract class Car{  
  3.     private String name;  
  4.     public abstract void drive();  
  5.     public String getName() {  
  6.         return name;  
  7.     }  
  8.     public void setName(String name) {  
  9.         this.name = name;  
  10.     }  
  11. }  
  12. //具體產品  
  13. class Benz extends Car{  
  14.     public void drive(){  
  15.         System.out.println(this.getName()+"----go-----------------------");  
  16.     }  
  17. }  
  18. class Bmw extends Car{  
  19.     public void drive(){  
  20.         System.out.println(this.getName()+"----go-----------------------");  
  21.     }  
  22. }  
  23. //抽象工廠  
  24. abstract class Driver{  
  25.     public abstract Car createCar(String car) throws Exception;  
  26. }  
  27. //具體工廠（每個具體工廠負責一個具體產品）  
  28. class BenzDriver extends Driver{  
  29.     public Car createCar(String car) throws Exception {  
  30.         return new Benz();  
  31.     }  
  32. }  
  33. class BmwDriver extends Driver{  
  34.     public Car createCar(String car) throws Exception {  
  35.         return new Bmw();  
  36.     }  
  37. }  
  38. //老闆  
  39. public class Boss{  
  40.     public static void main(String[] args) throws Exception {  
  41.         Driver d = new BenzDriver();  
  42.         Car c = d.createCar("benz");   
  43.         c.setName("benz");  
  44.         c.drive();  
  45.     }  
  46. }  

 使用開閉原則來分析下工廠方法模式。當有新的產品（即暴發戶的汽車）產生時，只要按照抽象產品角色、抽象工廠角色提供的合同來生成，那麼就可以被客戶使用，而不必去修改任何已有的程式碼。（即當有新產品時，只要建立並基礎抽象產品；新建具體工廠繼承抽象工廠；而不用修改任何一個類）工廠方法模式是完全符合開閉原則的！

使用工廠方法模式足以應付我們可能遇到的大部分業務需求。但是當產品種類非常多時，就會出現大量的與之對應的工廠類，這不應該是我們所希望的。所以我建議在這種情況下使用簡單工廠模式與工廠方法模式相結合的方式來減少工廠類：即對於產品樹上類似的種類（一般是樹的葉子中互為兄弟的）使用簡單工廠模式來實現。
當然特殊的情況，就要特殊對待了：對於系統中存在不同的產品樹，而且產品樹上存在產品族（下一節將解釋這個名詞）。那麼這種情況下就可能可以使用抽象工廠模式了。

五、小結

讓我們來看看簡單工廠模式、工廠方法模式給我們的啟迪：
如果不使用工廠模式來實現我們的例子，也許程式碼會減少很多——只需要實現已有的車，不使用多型。但是在可維護性上，可擴充套件性上是非常差的（你可以想象一下新增一輛車後要牽動的類）。因此為了提高擴充套件性和維護性，多寫些程式碼是值得的。

六、抽象工廠模式

先來認識下什麼是產品族： 位於不同產品等級結構中，功能相關聯的產品組成的家族。

圖中的BmwCar和BenzCar就是兩個產品樹（產品層次結構）；而如圖所示的BenzSportsCar和BmwSportsCar就是一個產品族。他們都可以放到跑車家族中，因此功能有所關聯。同理BmwBussinessCar和BenzBusinessCar也是一個產品族。
可以這麼說，它和工廠方法模式的區別就在於需要建立物件的複雜程度上。而且抽象工廠模式是三個裡面最為抽象、最具一般性的。抽象工廠模式的用意為：給客戶端提供一個介面，可以建立多個產品族中的產品物件。
而且使用抽象工廠模式還要滿足一下條件：
1.系統中有多個產品族，而系統一次只可能消費其中一族產品
2.同屬於同一個產品族的產品以其使用。
來看看抽象工廠模式的各個角色（和工廠方法的如出一轍）：
抽象工廠角色： 這是工廠方法模式的核心，它與應用程式無關。是具體工廠角色必須實現的介面或者必須繼承的父類。在java中它由抽象類或者介面來實現。
具體工廠角色：它含有和具體業務邏輯有關的程式碼。由應用程式呼叫以建立對應的具體產品的物件。在java中它由具體的類來實現。
抽象產品角色：它是具體產品繼承的父類或者是實現的介面。在java中一般有抽象類或者介面來實現。
具體產品角色：具體工廠角色所建立的物件就是此角色的例項。在java中由具體的類來實現。



 

Java程式碼  收藏程式碼

  1. //抽象產品（Bmw和Audi同理）  
  2. abstract class BenzCar{  
  3.     private String name;  
  4.     public abstract void drive();  
  5.     public String getName() {  
  6.         return name;  
  7.     }  
  8.     public void setName(String name) {  
  9.         this.name = name;  
  10.     }  
  11. }  
  12. //具體產品（Bmw和Audi同理）  
  13. class BenzSportCar extends BenzCar{  
  14.     public void drive(){  
  15.         System.out.println(this.getName()+"----BenzSportCar-----------------------");  
  16.     }  
  17. }  
  18. class BenzBusinessCar extends BenzCar{  
  19.     public void drive(){  
  20.         System.out.println(this.getName()+"----BenzBusinessCar-----------------------");  
  21.     }  
  22. }  
  23. abstract class BmwCar{  
  24.     private String name;  
  25.     public abstract void drive();  
  26.     public String getName() {  
  27.         return name;  
  28.     }  
  29.     public void setName(String name) {  
  30.         this.name = name;  
  31.     }  
  32. }  
  33. class BmwSportCar extends BmwCar{  
  34.     public void drive(){  
  35.         System.out.println(this.getName()+"----BmwSportCar-----------------------");  
  36.     }  
  37. }  
  38. class BmwBusinessCar extends BmwCar{  
  39.     public void drive(){  
  40.         System.out.println(this.getName()+"----BmwBusinessCar-----------------------");  
  41.     }  
  42. }  
  43. abstract class AudiCar{  
  44.     private String name;  
  45.     public abstract void drive();  
  46.     public String getName() {  
  47.         return name;  
  48.     }  
  49.     public void setName(String name) {  
  50.         this.name = name;  
  51.     }  
  52. }  
  53. class AudiSportCar extends AudiCar{  
  54.     public void drive(){  
  55.         System.out.println(this.getName()+"----AudiSportCar-----------------------");  
  56.     }  
  57. }  
  58. class AudiBusinessCar extends AudiCar{  
  59.     public void drive(){  
  60.         System.out.println(this.getName()+"----AudiBusinessCar-----------------------");  
  61.     }  
  62. }  
  63. //抽象工廠  
  64. abstract class Driver3{  
  65.     public abstract BenzCar createBenzCar(String car) throws Exception;  
  66.     public abstract BmwCar createBmwCar(String car) throws Exception;  
  67.     public abstract AudiCar createAudiCar(String car) throws Exception;  
  68. }  
  69. //具體工廠  
  70. class SportDriver extends Driver3{  
  71.     public BenzCar createBenzCar(String car) throws Exception {  
  72.         return new BenzSportCar();  
  73.     }  
  74.     public BmwCar createBmwCar(String car) throws Exception {  
  75.         return new BmwSportCar();  
  76.     }  
  77.     public AudiCar createAudiCar(String car) throws Exception {  
  78.         return new AudiSportCar();  
  79.     }  
  80. }  
  81. class BusinessDriver extends Driver3{  
  82.     public BenzCar createBenzCar(String car) throws Exception {  
  83.         return new BenzBusinessCar();  
  84.     }  
  85.     public BmwCar createBmwCar(String car) throws Exception {  
  86.         return new BmwBusinessCar();  
  87.     }  
  88.     public AudiCar createAudiCar(String car) throws Exception {  
  89.         return new AudiBusinessCar();  
  90.     }  
  91. }  
  92. //老闆  
  93. public class BossAbstractFactory {  
  94.     public static void main(String[] args) throws Exception {  
  95.         Driver3 d = new BusinessDriver();  
  96.         AudiCar car = d.createAudiCar("");  
  97.         car.drive();  
  98.     }  
  99. }  

其中：BenzSportCar和BenzBusinessCar屬於產品樹；同理BmwSportCar和BmwBusinessCar。而BenzSportCar和BmwSportCar和AudiSportCar屬於產品族。

所以抽象工廠模式一般用於具有產品樹和產品族的場景下。

抽象工廠模式的缺點：如果需要增加新的產品樹，那麼就要新增三個產品類，比如VolvoCar，VolvoSportCar,VolvoSportCar，並且要修改三個工廠類。這樣大批量的改動是很醜陋的做法。

所以可以用簡單工廠配合反射來改進抽象工廠：
UML圖略。

Java程式碼  收藏程式碼

  1. abstract class BenzCar{  
  2.     private String name;  
  3.     public abstract void drive();  
  4.     public String getName() {  
  5.         return name;  
  6.     }  
  7.     public void setName(String name) {  
  8.         this.name = name;  
  9.     }  
  10. }  
  11. class BenzSportCar extends BenzCar{  
  12.     public void drive(){  
  13.         System.out.println(this.getName()+"----BenzSportCar-----------------------");  
  14.     }  
  15. }  
  16. class BenzBusinessCar extends BenzCar{  
  17.     public void drive(){  
  18.         System.out.println(this.getName()+"----BenzBusinessCar-----------------------");  
  19.     }  
  20. }  
  21. abstract class BmwCar{  
  22.     private String name;  
  23.     public abstract void drive();  
  24.     public String getName() {  
  25.         return name;  
  26.     }  
  27.     public void setName(String name) {  
  28.         this.name = name;  
  29.     }  
  30. }  
  31. class BmwSportCar extends BmwCar{  
  32.     public void drive(){  
  33.         System.out.println(this.getName()+"----BmwSportCar-----------------------");  
  34.     }  
  35. }  
  36. class BmwBusinessCar extends BmwCar{  
  37.     public void drive(){  
  38.         System.out.println(this.getName()+"----BmwBusinessCar-----------------------");  
  39.     }  
  40. }  
  41. abstract class AudiCar{  
  42.     private String name;  
  43.     public abstract void drive();  
  44.     public String getName() {  
  45.         return name;  
  46.     }  
  47.     public void setName(String name) {  
  48.         this.name = name;  
  49.     }  
  50. }  
  51. class AudiSportCar extends AudiCar{  
  52.     public void drive(){  
  53.         System.out.println(this.getName()+"----AudiSportCar-----------------------");  
  54.     }  
  55. }  
  56. class AudiBusinessCar extends AudiCar{  
  57.     public void drive(){  
  58.         System.out.println(this.getName()+"----AudiBusinessCar-----------------------");  
  59.     }  
  60. }  
  61. /** 
  62.  * 簡單工廠通過反射改進抽象工廠及其子工廠 
  63.  * @author Administrator 
  64.  * 
  65.  */  
  66. class Driver3{  
  67.     public static BenzCar createBenzCar(String car) throws Exception {  
  68.         return (BenzCar) Class.forName(car).newInstance();  
  69.     }  
  70.     public static BmwCar createBmwCar(String car) throws Exception {  
  71.         return (BmwCar) Class.forName(car).newInstance();  
  72.     }  
  73.     public static AudiCar createAudiCar(String car) throws Exception {  
  74.         return (AudiCar) Class.forName(car).newInstance();  
  75.     }  
  76. }  
  77. //客戶端  
  78. public class SimpleAndAbstractFactory {  
  79.     public static void main(String[] args) throws Exception {  
  80.         AudiCar car = Driver3.createAudiCar("com.java.pattendesign.factory.AudiSportCar");  
  81.         car.drive();  
  82.     }  
  83. }  

策略模式

 從策略一詞來看,策略模式是種傾向於行為的模式.有點類似找仗時的做戰方案，一般司令員在做戰前都會根據實際情況做出幾套不同的方案，如果當時情況有變，就會根據相應的條件來判定用哪一套方案來替換原定方案。但無論如何替換，替換多少次，仗還是要打的。

  舉例：匯出成EXCEL，WORD，PDF檔案的功能，這三類匯出雖然具體操作略有不同，但是大部分都相同。


策略模式與工廠模式從uml圖上來說，基本一致。只是強調的封裝不同。我們以工廠模式和策略模式的比較來講解策略模式。

工廠模式我們可以做如下理解：假設有Audi的公司生產汽車，它掌握一項核心的技術就是生產汽車，另一方面，它生產的汽車是有不同型號的，並且在不同的生產線上進行組裝。當客戶通過銷售部門進行預定後，Audi公司將在指定的生產線上為客戶生產出它所需要的汽車。

策略(Strategy)模式在結構上與工廠模式類似，唯一的區別是工廠模式例項化一個產品的操作是在服務端來做的，換句話說客戶端傳達給服務端的只是某種標識，服務端根據該標識例項化一個物件。而策略模式的客戶端傳達給服務端的是一個例項，服務端只是將該例項拿過去在服務端的環境裡執行該例項的方法。這就好比一個對汽車不甚瞭解的人去買車，他在那一比劃，說要什麼什麼樣的，銷售部門根據他的這個“比劃”來形成一份訂單，這就是工廠模式下的工作方式。而策略模式下那個顧客就是個行家，他自己給出了訂單的詳細資訊，銷售部門只是轉了一下手就交給生產部門去做了。通過兩相對比，我們不難發現，採用工廠模式必須提供足夠靈活的銷售部門，如果使用者有了新的需求，銷售部門必須馬上意識到這樣才可以做出合適的訂單。所以倘一款新車出來了，生產部門和銷售部門都需要更新，對顧客來說也需要更新對新車的描述所以需要改動的地方有三處。而策略模式中的銷售部門工作比較固定，它只負責接受訂單並執行特定的幾個操作。當一款新車出來時，只需要對服務端的生產部門和客戶端的程式碼進行更新，而不需要更新銷售部門的程式碼。 

技術支援： 簡單工廠和策略的基礎都是因為面向物件的封裝與多型。他們實現的思想都是先設定一個抽象的模型並從該模型派生出符合不同客戶需求的各種方法，並加以封裝。

工廠模式和策略模式的區別在於例項化一個物件的位置不同，對工廠模式而言，例項化物件是放在服務端的，即放在了工廠類裡面；

而策略模式例項化物件的操作在客戶端，服務端的“銷售部門”只負責傳遞該物件，並在服務端的環境裡執行特定的操作。。。

工廠模式要求服務端的銷售部門足夠靈敏，而策略模式由於對策略進行了封裝，所以他的銷售部門比較傻，需要客戶提供足夠能區分使用哪種策略的引數，而這最好的就是該策略的例項了。

Java程式碼  收藏程式碼

  1. //抽象產品  
  2. abstract class AudiCar{  
  3.     private String name;  
  4.     public abstract void makeCar();  
  5.     public String getName() {  
  6.         return name;  
  7.     }  
  8.     public void setName(String name) {  
  9.         this.name = name;  
  10.     }  
  11. }  
  12. //具體產品  
  13. class AudiA6 extends AudiCar{  
  14.     public void makeCar(){  
  15.         System.out.println(this.getName()+"----go-----------------------");  
  16.     }  
  17. }  
  18. class AudiA4 extends AudiCar{  
  19.     public void makeCar(){  
  20.         System.out.println(this.getName()+"----go-----------------------");  
  21.     }  
  22. }  
  23. //銷售部門----服務端  
  24. class CarContext {  
  25.     AudiCar audiCar = null;  
  26.     public CarContext(AudiCar audiCar) {  
  27.         this.audiCar = audiCar;  
  28.     }  
  29.     public void orderCar(){  
  30.         this.audiCar.makeCar();  
  31.     }  
  32. }  
  33. //客戶----客戶端（這個客戶是內行，什麼都懂，他說我要A6，銷售部門立刻給他a6，所以銷售部門不用很懂）  
  34. public class SimplyFactoryAndStrategy2 {  
  35.     public static void main(String[] args) throws IOException {  
  36.         //客戶說我要什麼什麼樣子的車子，銷售人員才知道他要什麼樣子的車子  
  37.         AudiCar car = new AudiA6();  
  38.         car.setName("a6");  
  39.         CarContext context = new CarContext(car);  
  40.         context.orderCar();  
  41.     }  
  42. }  
  43. //工廠模式---與上面的策略模式比較  
  44. //抽象產品  
  45. abstract class AudiCar{  
  46.     private String name;  
  47.     public abstract void makeCar();  
  48.     public String getName() {  
  49.         return name;  
  50.     }  
  51.     public void setName(String name) {  
  52.         this.name = name;  
  53.     }  
  54. }  
  55. //具體產品  
  56. class AudiA6 extends AudiCar{  
  57.     public void makeCar(){  
  58.         System.out.println(this.getName()+"----go-----------------------");  
  59.     }  
  60. }  
  61. class AudiA4 extends AudiCar{  
  62.     public void makeCar(){  
  63.         System.out.println(this.getName()+"----go-----------------------");  
  64.     }  
  65. }  
  66. //簡單工廠---銷售部門----服務端  
  67. class CarFactroy{  
  68.     public static AudiCar createCar(String car){  
  69.         AudiCar c = null;  
  70.         if("A6".equalsIgnoreCase(car))  
  71.             c = new AudiA6();  
  72.         else if("A4".equalsIgnoreCase(car))  
  73.             c = new AudiA4();  
  74.         return c;  
  75.     }  
  76. }  
  77. //客戶----客戶端（這個客戶是外行，什麼都不懂，只要隨便描述下車，銷售部門才能知道他要那款車，所以銷售部門比較牛）  
  78. public class SimplyFactoryAndStrategy {  
  79.     public static void main(String[] args) throws IOException {  
  80.         System.out.print("請輸入您要坐的車：（A6、A4）");  
  81.         String carName = new BufferedReader(new InputStreamReader(System.in)).readLine();  
  82.         //客戶說我要什麼什麼樣子的車子，銷售人員才知道他要什麼樣子的車子  
  83.         AudiCar car = CarFactroy.createCar(carName);  
  84.         car.setName(carName);  
  85.         car.makeCar();    
  86.     }  
  87. }  

策略模式的優缺點

  策略模式的主要優點有：

  • 策略類之間可以自由切換，由於策略類實現自同一個抽象，所以他們之間可以自由切換。
  • 易於擴充套件，增加一個新的策略對策略模式來說非常容易，基本上可以在不改變原有程式碼的基礎上進行擴充套件。
  • 避免使用多重條件，如果不使用策略模式，對於所有的演算法，必須使用條件語句進行連線，通過條件判斷來決定使用哪一種演算法，在上一篇文章中我們已經提到，使用多重條件判斷是非常不容易維護的。

  策略模式的缺點主要有兩個：

  • 維護各個策略類會給開發帶來額外開銷，可能大家在這方面都有經驗：一般來說，策略類的數量超過5個，就比較令人頭疼了。
  • 必須對 客戶端（呼叫者）暴露所有的策略類，因為使用哪種策略是由客戶端來決定的，因此，客戶端應該知道有什麼策略，並且瞭解各種策略之間的區別，否則，後果很嚴 重。例如，有一個排序演算法的策略模式，提供了快速排序、氣泡排序、選擇排序這三種演算法，客戶端在使用這些演算法之前，是不是先要明白這三種演算法的適用情況？ 再比如，客戶端要使用一個容器，有連結串列實現的，也有陣列實現的，客戶端是不是也要明白連結串列和陣列有什麼區別？就這一點來說是有悖於迪米特法則的。

適用場景

        做面向物件設計的，對策略模式一定很熟悉，因為它實質上就是面向物件中的繼承和多型，在看完策略模式的通用程式碼後，我想，即使之前從來沒有聽說過策略模式，在開發過程中也一定使用過它吧？至少在在以下兩種情況下，大家可以考慮使用策略模式，

  • 幾個類的主要邏輯相同，只在部分邏輯的演算法和行為上稍有區別的情況。
  • 有幾種相似的行為，或者說演算法，客戶端需要動態地決定使用哪一種，那麼可以使用策略模式，將這些演算法封裝起來供客戶端呼叫。

       策略模式是一種簡單常用的模式，我們在進行開發的時候，會經常有意無意地使用它，一般來說，策略模式不會單獨使用，跟模版方法模式、工廠模式等混合使用的情況比較多。

相關推薦

工廠模式簡介和應用場景

結合簡單示例和UML圖，講解工廠模式簡單原理。 一、引子 話說十年前，有一個爆發戶，他家有三輛汽車（Benz（賓士）、Bmw（寶馬）、Audi（奧迪）），還僱了司機為他開車。不過，爆發戶坐車時總是這樣：上Benz車後跟司機說“開賓士車！”，坐上Bmw後他說“開寶馬

spark第一篇--簡介，應用場景和基本原理

為了滿足挖掘分析與互動式實時查詢的計算需求，騰訊大資料使用了Spark平臺來支援挖掘分析類計算、互動式實時查詢計算以及允許誤差範圍的快速查詢計算，目前騰訊大資料擁有超過200臺的Spark叢集，並獨立維護Spark和Shark分支。Spark叢集已穩定執行2年，我們積累了大量的案例和運營經驗能力，另外多

Android任務棧的四種模式和應用場景

通過Acitivty的xml標籤來改變任務棧的預設行為 在清單檔案中使用android:launchMode="standard|singleInstance|singleTask|singleT

老男孩教育每日一題-第83天-binlog是什麽?記錄的什麽?有幾種工作模式及企業應用場景

mysql binlog 每日一題 參考答案含義binlog：是用於記錄所有更新了數據的操作語句，語句以事件的形式保存，它描述數據的更改過程作用：用於實時備份數據，數據庫的主從復制log_bin 打開記錄binlog功能binlog的查看mysqlbinlog /home/mysql/binlog

Java設計模式之《單例模式》及應用場景

urn vol 運行 www 同步問題 href 外部 占用 模式 轉載參考:http://www.cnblogs.com/V1haoge/p/6510196.html 所謂單例，指的就是單實例，有且僅有一個類實例，這個單例不應該由人來控制，而應該由代碼來限制，強制單例。

Java設計模式之《外觀模式》及應用場景

nbsp str 之間 系統設計 static 系統 被調用 sub div 轉載參考:http://www.cnblogs.com/V1haoge/p/6484128.html 1、外觀模式簡介 　　外觀模式，一般用在子系統與訪問之間，用於對訪問屏蔽復雜的子系統調用，采用

Java設計模式之《代理模式》及應用場景

out ren 場景 語句 設計模式 rgs interface 中間 args 代理模式算是我接觸較早的模式，代理就是中介，中間人。法律上也有代理，比如代理律師之類，委托人將自己的一部分權限委托給代理者，代理者就擁有被代理者（委托人）的部分權限，並且可以以被代理人的名

MyISAM和InnoDB的主要區別和應用場景

事務安全 形式 acid sam 小型 inno type update 情況下 主要區別： 1).MyISAM是非事務安全型的，而InnoDB是事務安全型的。 2).MyISAM鎖的粒度是表級，而InnoDB支持行級鎖定。 3).MyISAM支持全文類型索引，而Inno

Java設計模式之《適配器模式》及應用場景

@override 一個 現在 無法 nds tool bar 通過 組合 適配器就是一種適配中間件，它存在於不匹配的二者之間，用於連接二者，將不匹配變得匹配，簡單點理解就是平常所見的轉接頭，轉換器之類的存在。 　　適配器模式有兩種：類適配器、對象適配器、接口適配器 　　前

Android：圖解四種啟動模式 及 實際應用場景解說

類型 placed data val add The avi 能夠 per 在一個項目中會包括著多個Activity，系統中使用任務棧來存儲創建的Activity實例，任務棧是一種“後進先出”的棧結構。舉個栗子，若我們多次啟動同一個Activity。系統會創建多個實例依次放

Redis簡介及應用場景

sub ffi Redis介紹 comment 插入數據 數據 tag l數據庫 排序 一丶Redis介紹 Redis是一個開源的 key—value型 單線程 數據庫，支持string、list、set、zset和hash類型數據。 默認端口:6379 默認數據庫數量:1

Alluxio原理和應用場景隨筆

    上週末有幸參加了Alluxio(之前也叫Tachyon)，七牛雲和示說網舉辦的Alluxio上海Meetup，之前我並沒有在真實應用場景中使用過Alluxio，對其適用的應用場景一直報懷疑態度。自信聆聽其創始人的演講之後，感覺這個專案還挺有意思，對Alluxio簡單總結一下：

Appium-python日誌logging模組的簡介和應用（2）

Python的logging模組定義的函式和類為應用程式和庫的開發實現提供了一個靈活的事件日誌系統。   Logging模組提供了兩種記錄日誌的方式： 第一種是使用logging提供的模組級別的函式 第二種是使用logging日誌系統的四大元件 此文主要使用

一篇文章詳解大資料技術和應用場景

什麼是大資料 說起大資料，估計大家都覺得只聽過概念，但是具體是什麼東西，怎麼定義，沒有一個標準的東西，因為在我們的印象中好像很多公司都叫大資料公司，業務形態則有幾百種，感覺不是很好理解，所以我建議還是從字面上來理解大資料，在維克托邁爾-舍恩伯格及肯尼斯庫克耶編寫的《大資料時代》提到了大資料的4個特徵：

Mybatis和Hibernate區別和應用場景

hibernate: 是一個標準的ORM框架（物件關係對映）。入門門檻較高，不需要程式寫sql語句，sql語句自動生產了。 特點： 對sql的優化比較困難。 Hibernate對物件的維護和快取要比MyBatis好，對增刪改查的物件的維護要方便。 Hibernate資料庫移植性很好，MyB

視訊影象的超解析度技術原理和應用場景

前言 影象和視訊通常包含著大量的視覺資訊，且視覺資訊本身具有直觀高效的描述能力，所以隨著資訊科技的高速發展，影象和視訊的應用逐漸遍佈人類社會的各個領域。近些年來，在計算機 影象處理、計算機視覺和機器學習等 領域中，來自工業界和學術界的許多學者和專家都持續關注著視訊影象的超解析度技術這個基

Redis特性和應用場景

Redis特性 速度快 Redis使用標準C編寫實現，而且將所有資料載入到記憶體中，所以速度非常快。官方提供的資料表明，在一個普通的Linux機器上，Redis讀寫速度分別達到81000/s和110000/s。 資料結構 可以將Redis看做“資料結構伺服器”。目前，Redis支援5

Linux 高精度定時器hrtimers簡單介紹和應用場景

hrtimer:high-resolution kernel timers:   hrtimers的誕生是由於核心開發者在使用過程中發現，原始的定時器kernel/timers.c,已經可以滿足所有場景的，但是在實際的大量測試中發現還是無法滿足所有場景，所以hrtime

[redis]redis五種資料型別和應用場景

一、String(字串)字串型別是redis最基礎的資料結構，首先鍵是字串型別，而且其他幾種結構都是在字串型別基礎上構建的，所以字串型別能為其他四種資料結構的學習尊定基礎。字串型別實際上可以是字串（簡單的字串、複雜的字串（xml、json）、數字（整數、浮點數）、二進位制（圖片、音訊、視訊）），但最大不能超過

物聯網技術NB-IOT的網路和應用場景

    NB－IoT的全稱是Narrow Band－Internet of Things，是基於蜂窩網路的窄帶物聯網技術，聚焦於低功耗廣域網，支援物聯網裝置在廣域網的蜂窩資料連線，可直接部署與LTE網路，可降低部署成本和實現平滑升級，是一種可在全球範圍內廣泛應用的一門物聯網技