工厂模式及什么时候用工厂模式

在设计模式中,Factory   Method也是比较简单的一个,但应用非常广泛,EJB,RMI,COM,CORBA,Swing中都可以看到此模式的影子,它是最重要的模式之一.在很多地方都会看到xxxFactory这样命名的类   
  Factory   Method是一种创建性模式,它定义了一个创建对象的接口,但是却让子类来决定具体实例化哪一个类.当一个类无法预料要创建哪种类的对象或是一个类需要 由子类来指定创建的对象时我们就需要用到Factory   Method   模式了.简单说来,Factory   Method可以根据不同的条件产生不同的实例,当然这些不同的实例通常是属于相同的类型,具有共同的父类.Factory   Method把创建这些实例的具体过程封装起来了,简化了客户端的应用,也改善了程序的扩展性,使得将来可以做最小的改动就可以加入新的待创建的类.   通常我们将Factory   Method作为一种标准的创建对象的方法,当发现需要更多的灵活性的时候,就开始考虑向其它创建型模式转化

工厂模式，也叫做说虚构造器，在简单工厂中间插入了一个具体产品工厂，这个工厂知道产品构造时候的具体细节，而简单工厂模式的产品具体构造细节是在一个个 if/else分支，或者在switch/case分支里面的。工厂模式的好处就在于将工厂和产品之间的耦合降低，将具体产品的构造过程放在了具体工厂类 里面。在以后扩展产品的时候方便很多，只需要添加一个工厂类，一个产品类，就能方便的添加产品，而不需要修改原有的代码。而在简单工厂中，如果要增加一个 产品，则需要修改工厂类，增加if/else分支，或者增加一个case分支，工厂模式符合软件开发中的OCP原则（open close principle），对扩展开放，对修改关闭。

工厂模式，实际上就是隐藏了实现的细节，用户不用关心对象是怎么创建出来的。

轉貼:   
    
  设计模式之Factory——买货篇   
  今天老婆让我去市场买一些水果，具体买什么自己定（哈，老婆放放权了！）。来到市场，我发现主要有一些水果：苹果（Apple），葡萄（Grape）和鸭梨（Pear）。   
  到底买什么好呢？我一阵思量。俗话说：“饭后一只烟，赛过活神仙。饭后吃苹果，西施见我躲。”为了老婆的漂亮，我决定买苹果。   
  好，言归正传，开始买吧！   
      
  主要有以下三种Factory模式：   
  Simple   Factory模式   
  专门定义一个类来负责创建其它类的实例，被创建的实例通常都具有共同的父类。     
  Factory   Method模式   
  将对象的创建交由父类中定义的一个标准方法来完成，而不是其构造函数，究竟应该创建何种对象由具体的子类负责决定。     
  Abstract   Factory模式   
  提供一个共同的接口来创建相互关联的多个对象。   
      
  一、Simple   Factory模式：   
  1、     在这里，我们先定义水果（Fruit）接口：   
  public   interface   Fruit   {   
      void   plant();     //水果是被种植的   
      void   enableEat();     //水果能吃   
  }   
  2、     苹果（Apple）是对水果（Fruit）接口的实现：   
  public   class   Apple   implements   Fruit{   
      public   void   plant(){   
          System.out.println("种苹果!");   
      }   
      public   void   enableEat(){   
          System.out.println("苹果好吃!");   
      }   
  }   
  3、     葡萄（Grape）是对水果（Fruit）接口的实现：   
  public   class   Grape   implements   Fruit{   
      public   void   plant(){   
          System.out.println("种葡萄!");   
      }   
      public   void   enableEat(){   
          System.out.println("葡萄好吃!");   
      }   
  }   
  4、     鸭梨（Pear）是对水果（Fruit）接口的实现：   
  public   class   Pear   implements   Fruit{   
      public   void   plant(){   
          System.out.println("种鸭梨!");   
      }   
      public   void   enableEat(){   
          System.out.println("鸭梨好吃!");   
      }   
  }   
  5、定义买水果（BuyFruit）这一过程类：   
  public   class   BuyFruit   {   
      /**   
      *   简单工厂方法   
      */   
      public   static   Fruit   buyFruit(String   which){   
          if   (which.equalsIgnoreCase("apple"))   {     //如果是苹果，则返回苹果实例   
              return   new   Apple();   
          }   
          else   if   (which.equalsIgnoreCase("pear")){     //如果是鸭梨，则返回鸭梨实例   
              return   new   Strawberry();   
          }   
          else   if   (which.equalsIgnoreCase("grape"))   {   //如果是葡萄，则返回葡萄实例   
              return   new   Grape();   
          }   
          else{   
              return   null;   
          }   
      }   
  }   
  6、     编写测试类：   
  public   class   FruitTest   {   
      public   static   void     main(String   args[]){   
          BuyFruit   buy   =   new   BuyFruit();       //开始买水果这个过程   
          buy.buyFruit("apple").enableEat();   //调用苹果的enableEat()方法   
      }   
  }   
  7、     说明：   
  A：我要购买苹果，只需向工厂角色（BuyFruit）请求即可。而工厂角色在接到请求后，会自行判断创建和提供哪一个产品。   
  B：但是对于工厂角色（BuyFruit）来说，增加新的产品（比如说增加草莓）就是一个痛苦的过程。工厂角色必须知道每一种产品，如何创建它们，以及何时向客户端提供它们。换言之，接纳新的产品意味着修改这个工厂。   
  C：因此Simple   Factory模式的开放性比较差。   
  有什么办法可以解决这个问题吗？那就需要Factory   Method模式来为我们服务了。   
  二、Factory   Method模式：   
  1、同样，我们先定义水果（Fruit）接口：   
  public   interface   Fruit   {   
      void   plant();     //水果是被种植的   
      void   enableEat();     //水果能吃   
  }   
  2、苹果（Apple）是对水果（Fruit）接口的实现：   
  public   class   Apple   implements   Fruit{   
      public   void   plant(){   
          System.out.println("种苹果!");   
      }   
      public   void   enableEat(){   
          System.out.println("苹果好吃!");   
      }   
  }   
  3、葡萄（Grape）是对水果（Fruit）接口的实现：   
  public   class   Grape   implements   Fruit{   
      public   void   plant(){   
          System.out.println("种葡萄!");   
      }   
      public   void   enableEat(){   
          System.out.println("葡萄好吃!");   
      }   
  }   
  4、鸭梨（Pear）是对水果（Fruit）接口的实现：   
  public   class   Pear   implements   Fruit{   
      public   void   plant(){   
          System.out.println("种鸭梨!");   
      }   
      public   void   enableEat(){   
          System.out.println("鸭梨好吃!");   
      }   
  }   
  5、在这里我们将买水果（BuyFruit）定义为接口类：   
  public   interface   BuyFruit{   
      /**   
      *   工厂方法   
      */   
      public   Fruit   buyFruit();       //定义买水果这一过程   
  }   
  6、买苹果是（BuyApple）对买水果（BuyFruit）这个接口的实现   
  public   class   BuyApple   implements   BuyFruit{   
      public   Fruit   buyFruit(){   
          return   new   Apple();     //返回苹果实例   
  }   
  }   
  7、买鸭梨是（BuyPear）对买水果（BuyFruit）这个接口的实现   
  public   class   BuyPear   implements   BuyFruit{   
      public   Fruit   BuyPear   (){   
          return   new   Pear();     //返回鸭梨实例   
  }   
  }   
  8、买葡萄是（BuyGrape）对买水果（BuyFruit）这个接口的实现   
  public   class   BuyGrape   implements   BuyFruit{   
      public   Fruit   BuyGrape   (){   
          return   new   Grape   ();     //返回葡萄实例   
  }   
  }   
  9、编写测试类：   
  public   class   FruitTest   {   
      public   static   void     main(String   args[]){   
          BuyApple   buy   =   new   BuyApple();   //开始买水果这个过程   
          buy.buyFruit().enableEat();             //调用苹果的enableEat()方法   
      }   
  }   
  10、说明：   
  A：工厂方法模式和简单工厂模式在结构上的不同是很明显的。工厂方法模式的核心是一个抽象工厂类，而简单工厂模式把核心放在一个具体类上。工厂方法模式可 以允许很多具体工厂类从抽象工厂类中将创建行为继承下来，从而可以成为多个简单工厂模式的综合，进而推广了简单工厂模式。   
  B：工厂方法模式退化后可以变得很像简单工厂模式。设想如果非常确定一个系统只需要一个具体工厂类，那么就不妨把抽象工厂类合并到具体的工厂类中去。由于 反正只有一个具体工厂类，所以不妨将工厂方法改成为静态方法，这时候就得到了简单工厂模式。C：如果需要加入一个新的水果，那么只需要加入一个新的水果类 以及它所对应的工厂类。没有必要修改客户端，也没有必要修改抽象工厂角色或者其他已有的具体工厂角色。对于增加新的水果类而言，这个系统完全支持“开-闭 ”原则。   
  D：对Factory   Method模式而言，它只是针对一种类别（如本例中的水果类Fruit），但如果我们还想买肉，那就不行了，这是就必须要Factory   Method模式帮忙了。   
  三、Abstract   Factory模式   
  1、同样，我们先定义水果（Fruit）接口：   
  public   interface   Fruit   {   
      void   plant();     //水果是被种植的   
      void   enableEat();     //水果能吃   
  }   
  2、苹果（Apple）是对水果（Fruit）接口的实现：   
  public   class   Apple   implements   Fruit{   
      public   void   plant(){   
          System.out.println("种苹果!");   
      }   
      public   void   enableEat(){   
          System.out.println("苹果好吃!");   
      }   
  }   
  3、葡萄（Grape）是对水果（Fruit）接口的实现：   
  public   class   Grape   implements   Fruit{   
      public   void   plant(){   
          System.out.println("种葡萄!");   
      }   
      public   void   enableEat(){   
          System.out.println("葡萄好吃!");   
      }   
  }   
  4、鸭梨（Pear）是对水果（Fruit）接口的实现：   
  public   class   Pear   implements   Fruit{   
      public   void   plant(){   
          System.out.println("种鸭梨!");   
      }   
      public   void   enableEat(){   
          System.out.println("鸭梨好吃!");   
      }   
  }   
  5、     定义肉（Meat）接口：   
  public   interface   Meat   {   
      void   feed();     //肉是喂养的   
      void   enableEat();     //肉能吃   
  }   
  6、     猪肉（BigMeat）是对肉（Meat）接口的实现：   
  public   class   BigMeat   implements   Meat{   
      public   void   feed(){   
          System.out.println("养猪!");   
      }   
      public   void   enableEat(){   
          System.out.println("猪肉好吃!");   
      }   
  }   
  7、     牛肉（CowMeat）是对肉（Meat）接口的实现：   
  public   class   CowMeat   implements   Meat   {   
      public   void   feed(){   
          System.out.println("养牛!");   
      }   
      public   void   enableEat(){   
          System.out.println("牛肉好吃!");   
      }   
  }   
  8、     我们可以定义买货人（Buyer）接口：   
  public   interface   Buyer   {   
      /**   
        *   买水果工厂方法   
        */   
      public   Fruit   buyFruit(Fruit   whichFruit);   
      /**   
        *   买肉的工厂方法   
        */   
      public   Meat   buyMeat(Meat   whichMeat);   
  }   
  9、     我（MyBuyer）是对买货人（Buyer）接口的实现：   
  public   class   MyBuyer   implements   Buyer{   
      /**   
        *   买水果工厂方法   
        */   
      public   Fruit   buyFruit(Fruit   whichFruit){   
            return   whichFruit;   
      }   
      /**   
        *   买肉的工厂方法   
        */   
      public   Meat   buyMeat(Meat   whichMeat){   
            return   whichMeat;   
      }   
  }   
  10、编写测试类：   
  public   class   MyBuyerAbstractTest   {   
      public   static   void     main(String   args[]){   
          Fruit   apple   =   new   Apple();       //苹果实例   
          Meat   big   =   new   BigMeat();     //猪肉实例   
          MyBuyer   my   =   new   MyBuyer();     //我是买者的实例   
          my.buyFruit(apple).enableEat();     //我买苹果   
          my.buyMeat(big).enableEat();         //我买猪肉   
      }   
  }     
  11、说明：   
  A：抽象工厂模式可以向客户端提供一个接口，使得客户端在不必指定产品的具体类型的情况下，创建多个产品族中的产品对象。这就是抽象工厂模式的用意。   
  B：抽象工厂模式是所有形态的工厂模式中最为抽象和最具一般性的一种形态。   
  C：抽象工厂模式与工厂方法模式的最大区别就在于，工厂方法模式针对的是一个产品（Fruit）等级结构；而抽象工厂模式则需要面对多个产品等级结构(Fruit、Meat)。