簡單工廠模式的介紹、優缺點分析和解決方案

所有的模式都是利用java中的封裝、繼承、多態這三個特性張開的，就像由這三個秘籍組成的各種變幻萬千的招式，而所有的目的都是為了打敗壞模式帶來的代碼垃圾這個敵人，所有的招式都是要求“可維護”、“可擴展”、“可復用”，當然如果達到這三個標准后，基本上“靈活性好”同時也就擁有了。 所以下面介紹最常用的工廠模式，分為三類：簡單工廠模式、工廠模式和抽象工廠模式。

一、簡單工廠模式

1.介紹

      工廠模式，顧名思義，最少有一個生產產品的機器存在的工廠Factory，與此同時，也要有一個構建好的產品模塊Product。所以，我們要用到Factory來創造Product。在簡單工廠模式中，有幾種角色存在。一個是所有產品的父類P，即所有產品的模板；另外一個是繼承了父類P的產品子類p1，p2...;當然，最重要的是Factory，在Factory中可以將這些的產品實例化，根據需求來將Factory和Product產生聯系。

2.例子 

      我們先來做一個例子吧，以做一個簡單的計算器來開始。

    a.  Product的父類： Operation

 
          
 
          public  
          class Operation { 
          
 
          
     
          private  
          double _numberA = 0 ; 
          
     
          private  
          double _numberB = 0; 
          
     
          private  
          double result = 0; 
          
     
          public  
          double get_numberA() { 
          
         
          return _numberA; 
          
    } 
          
     
          public  
          void set_numberA( 
          double _numberA) { 
          
         
          this._numberA = _numberA; 
          
    } 
          
     
          public  
          double get_numberB() { 
          
         
          return _numberB; 
          
    } 
          
     
          public  
          void set_numberB( 
          double _numberB) { 
          
         
          this._numberB = _numberB; 
          
    } 
          
     
          public  
          double getResult() { 
          
         
          return result; 
          
    } 
          
     
          public  
          void setResult( 
          double result) { 
          
         
          this.result = result; 
          
    } 
          
     
          
     
          
} 
         

 

 b.繼承了Product的子類：加法產品（OperationAdd），乘法產品（OperationMul），減法產品（OperationSub），除法產品（OperationDiv）

 

public  class  OperationAdd  extends  Operation{
    @Override
     public  double getResult(){
         double result = 0;
        result = get_numberA() + get_numberB();
         return result;
    }
}

public  class OperationSub  extends Operation{

    @Override
     public  double getResult(){
         double result = 0 ;
        result = get_numberA() - get_numberB();
         return result;
    }
}

public  class OperationMul  extends Operation {

    @Override
     public  double getResult(){
         double result = 0;
        result = get_numberA()*get_numberB();
         return result;
    }
}

public  class OperationDiv  extends Operation{

    @Override
     public  double getResult(){
         double result = 0 ;
         if(get_numberB() == 0){
             throw  new RuntimeException("除數不能為0.");
        } else{
            result = get_numberA()/get_numberB();
             return result;
        }
       
    }
}

 c.生產產品的工廠Factory（OperationFactory）

package SimpleFactory;
public  class OperationFactory {

     public  static Operation createOperation(String operate){
        Operation oper =  null;
         switch(operate)
        {
         case "+" :
            oper =  new OperationAdd() ;
             break;
         case "-" :
            oper =  new OperationSub() ;
             break;
         case "*" :
            oper =  new OperationMul() ;
             break;
         case "/" :
            oper =  new OperationDiv() ;
             break;
        }
         return oper;
    } }

最后我們把工廠和產品做好以后就可以，將產品買給客戶啦。

public  class Client {

     public  static  void main(String[] args) {
        test();
    }
    
     public  static  void test(){
        Operation oper = OperationFactory.createOperation("+");
        oper.set_numberA(1);
        oper.set_numberB(2);
         double result = oper.getResult();
        System.out.println(result);
    }

} 

結果當然是：3.0啦。

 這就是最簡單的工廠模式，說到優點，這個簡單工廠用了java中繼承，將決定工廠的生產什么產品的決定權直接交到了客戶手中，然后客戶在輸入自己的需求，得到最終的結果。

這樣模塊清晰化，每個部分都各司其職，分工明確，代碼就實現最漸層意義上的“可維護”啦。說到缺點，當我們需要增加一產品，比如在計算機中加入一個新的功能，可以求M的N次方，這樣個小功能我們就要去添加一個新的類，同時我們需要在Factory中改動到switch里面的代碼，這是耦合性很高的表現啦，所以我們就有了“工廠模式”的出現啦。