點擊上方「JAVA樂園」，選擇「置頂公衆號」
java

有內涵有價值的文章第一時間送達！程序員

1、簡單工廠模式web

一個栗子：
我喜歡吃麪條，抽象一個麪條基類，(接口也能夠)，這是產品的抽象類。編程

public abstract class INoodles {      //描述每種麪條啥樣的   
    public abstract void desc(); }

先來一份蘭州拉麪（具體的產品類）：微信

public class LzNoodles extends INoodles {    @Override    
    public void desc() {        System.out.println("蘭州拉麪 上海的好貴 家裏才5 6塊錢一碗");    } }

程序員加班必備也要吃泡麪（具體的產品類）：session

public class PaoNoodles extends INoodles {    @Override    
    public void desc() {        System.out.println("泡麪好吃 可不要貪杯");    } }

還有我最愛吃的家鄉的幹扣面（具體的產品類）：app

public class GankouNoodles extends INoodles {    @Override    
    public void desc() {        System.out.println("仍是家裏的幹扣面好吃 6塊一碗");    } }

準備工做作完了，咱們來到一家「簡單面館」（簡單工廠類），菜單以下：ide

public class SimpleNoodlesFactory {    
    public static final int TYPE_LZ = 1;//蘭州拉麪
    public static final int TYPE_PM = 2;//泡麪
    public static final int TYPE_GK = 3;//幹扣面

    public static INoodles createNoodles(int type) {        switch (type) {            
       case TYPE_LZ:                
          return new LzNoodles();            
       case TYPE_PM:                
          return new PaoNoodles();            
      case TYPE_GK:            
      default:                
          return new GankouNoodles();        }    } }

簡單面館就提供三種麪條（產品），你說你要啥，他就給你啥。這裏我點了一份幹扣面:flex

// 簡單工廠模式 INoodles noodles = SimpleNoodlesFactory.createNoodles(SimpleNoodlesFactory.TYPE_GK); noodles.desc();

輸出：this

仍是家裏的幹扣面好吃 6塊一碗

特色

1 它是一個具體的類，非接口抽象類。有一個重要的create()方法，利用if或者 switch建立產品並返回。

2 create()方法一般是靜態的，因此也稱之爲靜態工廠。

缺點

1 擴展性差（我想增長一種麪條，除了新增一個麪條產品類，還須要修改工廠類方法）

2 不一樣的產品須要不一樣額外參數的時候不支持。

2、工廠方法模式

1.模式描述

提供一個用於建立對象的接口(工廠接口)，讓其實現類(工廠實現類)決定實例化哪個類(產品類)，而且由該實現類建立對應類的實例。

2.模式做用

能夠必定程度上解耦，消費者和產品實現類隔離開，只依賴產品接口(抽象產品)，產品實現類如何改動與消費者徹底無關。

能夠必定程度增長擴展性，若增長一個產品實現，只須要實現產品接口，修改工廠建立產品的方法，消費者能夠無感知（若消費者不關心具體產品是什麼的狀況）。
能夠必定程度增長代碼的封裝性、可讀性。清楚的代碼結構，對於消費者來講不多的代碼量就能夠完成不少工做。
等等。//TODO
另外，抽象工廠纔是實際意義的工廠模式，工廠方法只是抽象工廠的一個比較常見的狀況。

3.適用場景

消費者不關心它所要建立對象的類(產品類)的時候。

消費者知道它所要建立對象的類(產品類)，但不關心如何建立的時候。

等等。//TODO

例如：hibernate裏經過sessionFactory建立session、經過代理方式生成ws客戶端時，經過工廠構建報文中格式化數據的對象。

4.模式要素

提供一個產品類的接口。產品類均要實現這個接口(也能夠是abstract類，即抽象產品)。
提供一個工廠類的接口。工廠類均要實現這個接口(即抽象工廠)。
由工廠實現類建立產品類的實例。工廠實現類應有一個方法，用來實例化產品類。

5.類圖

6.模式實例代碼

工廠：

package com.demoFound.factoryMethod.factory;    import com.demoFound.factoryMethod.message.IMyMessage;    /** * 工廠方法模式_工廠接口 *   * @author popkidorc *   */  
public interface IMyMessageFactory {        public IMyMessage createMessage(String messageType);   }

package com.demoFound.factoryMethod.factory;  import java.util.HashMap;  
import java.util.Map;  import com.demoFound.factoryMethod.message.IMyMessage; 
import com.demoFound.factoryMethod.message.MyMessageEmail; import com.demoFound.factoryMethod.message.MyMessageOaTodo; import com.demoFound.factoryMethod.message.MyMessageSms;    /** * 工廠方法模式_工廠實現 * @author popkidorc *   */  
public class MyMessageFactory implements IMyMessageFactory {        @Override      public IMyMessage createMessage(String messageType) {          // 這裏的方式是：消費者知道本身想要什麼產品；若生產何種產品徹底由工廠決定，則這裏不該該傳入控制生產的參數。          IMyMessage myMessage;          Map<String, Object> messageParam = new HashMap<String, Object>();          // 根據某些條件去選擇究竟建立哪個具體的實現對象，條件能夠傳入的，也能夠從其它途徑獲取。          // sms  
        if ("SMS".equals(messageType)) {              myMessage = new MyMessageSms();              messageParam.put("PHONENUM", "123456789");          } else  
        // OA待辦  
        if ("OA".equals(messageType)) {              myMessage = new MyMessageOaTodo();              messageParam.put("OAUSERNAME", "testUser");          } else  
        // email  
        if ("EMAIL".equals(messageType)) {              myMessage = new MyMessageEmail();              messageParam.put("EMAIL", "test@test.com");          } else  
        // 默認生產email這個產品          {              myMessage = new MyMessageEmail();              messageParam.put("EMAIL", "test@test.com");          }          myMessage.setMessageParam(messageParam);          return myMessage;      }   }

產品：

package com.demoFound.factoryMethod.message;    import java.util.Map;    /** * 工廠方法模式_產品接口 *   * @author popkidorc *   */  
public interface IMyMessage {        public Map<String, Object> getMessageParam();        public void setMessageParam(Map<String, Object> messageParam);        public void sendMesage() throws Exception;// 發送通知/消息    }

package com.demoFound.factoryMethod.message;    import java.util.Map;    /** * 工廠方法模式_虛擬產品類 *   * @author popkidorc *   */  
public abstract class MyAbstractMessage implements IMyMessage {        private Map<String, Object> messageParam;// 這裏能夠理解爲生產產品所須要的原材料庫。最好是個自定義的對象，這裏爲了避免引發誤解使用Map。        @Override      public Map<String, Object> getMessageParam() {          return messageParam;      }        @Override      public void setMessageParam(Map<String, Object> messageParam) {          this.messageParam = messageParam;      }   }

package com.demoFound.factoryMethod.message;    /** * 工廠方法模式_email產品 *   * @author popkidorc *   */  
public class MyMessageEmail extends MyAbstractMessage {        @Override      public void sendMesage() throws Exception {          // TODO Auto-generated method stub  
        if (null == getMessageParam() || null == getMessageParam().get("EMAIL")                  || "".equals(getMessageParam().get("EMAIL"))) {              throw new Exception("發送短信,須要傳入EMAIL參數");// 爲了簡單起見異常也不自定義了  
        }// 另外郵件內容，以及其餘各類協議參數等等都要處理            System.out.println("我是郵件，發送通知給" + getMessageParam().get("EMAIL"));      }     }

package com.demoFound.factoryMethod.message;    /** * 工廠方法模式_oa待辦產品 *   * @author popkidorc *   */  
public class MyMessageOaTodo extends MyAbstractMessage {        @Override      public void sendMesage() throws Exception {          // TODO Auto-generated method stub  
        if (null == getMessageParam()                  || null == getMessageParam().get("OAUSERNAME")                  || "".equals(getMessageParam().get("OAUSERNAME"))) {              throw new Exception("發送OA待辦,須要傳入OAUSERNAME參數");// 爲了簡單起見異常也不自定義了  
        }// 這裏的參數需求就比較多了不一一處理了            System.out                  .println("我是OA待辦，發送通知給" + getMessageParam().get("OAUSERNAME"));      }     }

package com.demoFound.factoryMethod.message;    /** * 工廠方法模式_sms產品 *   * @author popkidorc *   */  
public class MyMessageSms extends MyAbstractMessage {        @Override      public void sendMesage() throws Exception {          // TODO Auto-generated method stub  
        if (null == getMessageParam()                  || null == getMessageParam().get("PHONENUM")                  || "".equals(getMessageParam().get("PHONENUM"))) {              throw new Exception("發送短信,須要傳入PHONENUM參數");// 爲了簡單起見異常也不自定義了  
        }// 另外短信信息，以及其餘各類協議參數等等都要處理            System.out.println("我是短信，發送通知給" + getMessageParam().get("PHONENUM"));      }     }

消費者：

package com.demoFound.factoryMethod;  import com.demoFound.factoryMethod.factory.IMyMessageFactory; import com.demoFound.factoryMethod.factory.MyMessageFactory; import com.demoFound.factoryMethod.message.IMyMessage;    /** * 工廠方法模式_消費者類 *   * @author popkidorc *   */  
public class MyFactoryMethodMain {        public static void main(String[] args) {          IMyMessageFactory myMessageFactory = new MyMessageFactory();          IMyMessage myMessage;          // 對於這個消費者來講，不用知道如何生產message這個產品，耦合度下降  
        try {              // 先來一個短信通知  
            myMessage = myMessageFactory.createMessage("SMS");              myMessage.sendMesage();                // 來一個oa待辦  
            myMessage = myMessageFactory.createMessage("OA");              myMessage.sendMesage();                // 來一個郵件通知  
            myMessage = myMessageFactory.createMessage("EMAIL");              myMessage.sendMesage();          } catch (Exception e) {              e.printStackTrace();          }      }   }

3、抽象工廠模式

定義：爲建立一組相關或相互依賴的對象提供一個接口，並且無需指定他們的具體類。

類型：建立類模式

類圖：

抽象工廠模式與工廠方法模式的區別

抽象工廠模式是工廠方法模式的升級版本，他用來建立一組相關或者相互依賴的對象。他與工廠方法模式的區別就在於，工廠方法模式針對的是一個產品等級結構；而抽象工廠模式則是針對的多個產品等級結構。在編程中，一般一個產品結構，表現爲一個接口或者抽象類，也就是說，工廠方法模式提供的全部產品都是衍生自同一個接口或抽象類，而抽象工廠模式所提供的產品則是衍生自不一樣的接口或抽象類。

在抽象工廠模式中，有一個產品族的概念：所謂的產品族，是指位於不一樣產品等級結構中功能相關聯的產品組成的家族。抽象工廠模式所提供的一系列產品就組成一個產品族；而工廠方法提供的一系列產品稱爲一個等級結構。咱們依然拿生產汽車的例子來講明他們之間的區別。

在上面的類圖中，兩廂車和三廂車稱爲兩個不一樣的等級結構；而2.0排量車和2.4排量車則稱爲兩個不一樣的產品族。再具體一點，2.0排量兩廂車和2.4排量兩廂車屬於同一個等級結構，2.0排量三廂車和2.4排量三廂車屬於另外一個等級結構；而2.0排量兩廂車和2.0排量三廂車屬於同一個產品族，2.4排量兩廂車和2.4排量三廂車屬於另外一個產品族。

明白了等級結構和產品族的概念，就理解工廠方法模式和抽象工廠模式的區別了，若是工廠的產品所有屬於同一個等級結構，則屬於工廠方法模式；若是工廠的產品來自多個等級結構，則屬於抽象工廠模式。在本例中，若是一個工廠模式提供2.0排量兩廂車和2.4排量兩廂車，那麼他屬於工廠方法模式；若是一個工廠模式是提供2.4排量兩廂車和2.4排量三廂車兩個產品，那麼這個工廠模式就是抽象工廠模式，由於他提供的產品是分屬兩個不一樣的等級結構。固然，若是一個工廠提供所有四種車型的產品，由於產品分屬兩個等級結構，他固然也屬於抽象工廠模式了。

抽象工廠模式代碼

interface IProduct1 {      public void show();   }  interface IProduct2 {      public void show();   }  
class Product1 implements IProduct1 {      public void show() {          System.out.println("這是1型產品");      }   }  

class Product2 implements IProduct2 {      public void show() {          System.out.println("這是2型產品");      }   }    interface IFactory {      public IProduct1 createProduct1();      public IProduct2 createProduct2();   }  class Factory implements IFactory{      public IProduct1 createProduct1() {          return new Product1();      }      public IProduct2 createProduct2() {          return new Product2();      }   }    public class Client {      public static void main(String[] args){          IFactory factory = new Factory();          factory.createProduct1().show();          factory.createProduct2().show();      }   }

抽象工廠模式的優勢

抽象工廠模式除了具備工廠方法模式的優勢外，最主要的優勢就是能夠在類的內部對產品族進行約束。所謂的產品族，通常或多或少的都存在必定的關聯，抽象工廠模式就能夠在類內部對產品族的關聯關係進行定義和描述，而沒必要專門引入一個新的類來進行管理。

抽象工廠模式的缺點

產品族的擴展將是一件十分費力的事情，假如產品族中須要增長一個新的產品，則幾乎全部的工廠類都須要進行修改。因此使用抽象工廠模式時，對產品等級結構的劃分是很是重要的。

適用場景

當須要建立的對象是一系列相互關聯或相互依賴的產品族時，即可以使用抽象工廠模式。說的更明白一點，就是一個繼承體系中，若是存在着多個等級結構（即存在着多個抽象類），而且分屬各個等級結構中的實現類之間存在着必定的關聯或者約束，就可使用抽象工廠模式。假如各個等級結構中的實現類之間不存在關聯或約束，則使用多個獨立的工廠來對產品進行建立，則更合適一點。

總結

不管是簡單工廠模式，工廠方法模式，仍是抽象工廠模式，他們都屬於工廠模式，在形式和特色上也是極爲類似的，他們的最終目的都是爲了解耦。在使用時，咱們沒必要去在乎這個模式到底工廠方法模式仍是抽象工廠模式，由於他們之間的演變經常是使人琢磨不透的。常常你會發現，明明使用的工廠方法模式，當新需求來臨，稍加修改，加入了一個新方法後，因爲類中的產品構成了不一樣等級結構中的產品族，它就變成抽象工廠模式了；而對於抽象工廠模式，當減小一個方法使的提供的產品再也不構成產品族以後，它就演變成了工廠方法模式。

因此，在使用工廠模式時，只須要關心下降耦合度的目的是否達到了。

class Engine {      public void getStyle(){          System.out.println("這是汽車的發動機");      }   }  class Underpan {      public void getStyle(){          System.out.println("這是汽車的底盤");      }   }  class Wheel {      public void getStyle(){          System.out.println("這是汽車的輪胎");      }   }  public class Client {      public static void main(String[] args) {          Engine engine = new Engine();          Underpan underpan = new Underpan();          Wheel wheel = new Wheel();          ICar car = new Car(underpan, wheel, engine);          car.show();      }   }

看到這裏了，不關注一下麼

JAVA樂園

一碼不掃，何掃天下

java設計模式之工廠模式