工厂模式（其实我们一直都在用工厂模式）

  已经有很多介绍工厂模式的文章了。这里整理汇总下。

1、工厂模式的核心思想及分类

    工厂方法模式的作用是负责实例化同一个接口的多个类。工厂方法模式的意义是定义一个创建产品对象的工厂类，由该工厂统一创建继承了同一个接口的多个产品对象。

    工厂方法可以分为三个子类型：
  

    * 工厂方法模式（Factory Method):最基本的工厂模式；
    *     多个工厂方法模式：对工厂方法模式的扩展；
    *     简单工厂模式（Simple Factory）：一种特殊的工厂模式，其工厂方法是静态的，因此也称为静态工厂方法模式


2、第一种——工厂方法模式

    工厂方法模式提供了一个工厂方法类，并提供了一个工厂方法函数，该方法负责创建所有的抽象产品对象。
    仍然使用互联网上广为流传的****户装B的例子：
    话说十年前，有一个****户，他家有三辆汽车——Benz奔驰、Bmw宝马、Audi奥迪，还雇了司机为他开车。不过，****户坐车时总是怪怪的：上 Benz车后跟司机说“开奔驰车！”，坐上Bmw后他说“开宝马车！”，坐上Audi说“开奥迪车！”。你一定说：这人有病！直接说开车不就行了？！
    而当把这个暴发户的行为放到我们程序设计中来时，会发现这是一个普遍存在的现象。幸运的是，这种有病的现象在OO（面向对象）语言中可以避免了。
  
Java代码  收藏代码

   1. //接口(抽象产品角色) 
   2. public interface Car{ 
   3.       public void drive(); 
   4. } 
   5.  
   6. //具体产品角色 
   7. public class Benz implements Car{ 
   8.       public void drive() { 
   9.          System.out.println("Driving Benz "); 
  10.       } 
  11. } 
  12.  
  13. public class Bmw implements Car{ 
  14.       public void drive() { 
  15.        System.out.println("Driving Bmw "); 
  16.       } 
  17. } 
  18. //...其他车的实现 
  19.  
  20. //工厂方法类 
  21. public class Driver{ 
  22.      //工厂方法.注意 返回类型为抽象产品角色 
  23.      public Car driveCar(String s)throws Exception{ 
  24.      //判断逻辑，返回具体的产品角色给Client 
  25.      if(s.equalsIgnoreCase("Benz")) 
  26.            return new Benz(); 
  27.      else if(s.equalsIgnoreCase("Bmw")) 
  28.            return new Bmw(); 
  29.       ......    
  30.      else throw new Exception(); 
  31.      } 
  32. } 
  33.  
  34. //使用：欢迎暴发户出场..... 
  35. public class Magnate{ 
  36.      public static void main(String[] args){ 
  37.         try{ 
  38.           Driver driver = new Driver(); 
  39.           //告诉司机我今天坐奔驰                     
  40.           Car car = driver.driveCar("benz"); 
  41.           //下命令：开车                            
  42.           car.drive(); 
  43.           ... 
  44.          } 
  45.       } 

//接口(抽象产品角色)
public interface Car{
      public void drive();
}

//具体产品角色
public class Benz implements Car{
      public void drive() {
         System.out.println("Driving Benz ");
      }
}

public class Bmw implements Car{
      public void drive() {
       System.out.println("Driving Bmw ");
      }
}
//...其他车的实现

//工厂方法类
public class Driver{
     //工厂方法.注意 返回类型为抽象产品角色
     public Car driveCar(String s)throws Exception{
     //判断逻辑，返回具体的产品角色给Client
     if(s.equalsIgnoreCase("Benz"))
           return new Benz();
     else if(s.equalsIgnoreCase("Bmw"))
           return new Bmw();
      ......  
     else throw new Exception();
     }
}

//使用：欢迎暴发户出场.....
public class Magnate{
     public static void main(String[] args){
        try{
          Driver driver = new Driver();
          //告诉司机我今天坐奔驰                   
          Car car = driver.driveCar("benz");
          //下命令：开车                          
          car.drive();
          ...
         }
      }



3、第二种——多个工厂方法模式
    对于第一种工厂方法模式。每次调用driveCar函数时必须传入一个类型参数。这种工厂类显得比较稚嫩，因为当传递参数错误时，就不能正确的创建产品。
    第二种工厂模式为工厂类提供多个工厂方法，分别创建不同的产品对象。
    //工厂方法类
Java代码  收藏代码

   1. public class Driver{ 
   2.      public Car driveBmw(){ 
   3.            return new Bmw(); 
   4.      } 
   5.        
   6.      public Car driveBenz(){ 
   7.            return new Benz(); 
   8.      } 
   9.  
  10.     //.... 
  11. } 
  12.  
  13. //使用：欢迎暴发户出场..... 
  14. public class Magnate{ 
  15.      public static void main(String[] args){ 
  16.         try{ 
  17.           Driver driver = new Driver(); 
  18.           //告诉司机我今天坐奔驰                     
  19.           Car car = driver.driveBenz(); 
  20.           //下命令：开车                            
  21.           car.drive(); 
  22.           ... 
  23.          } 
  24.       } 

public class Driver{
     public Car driveBmw(){
           return new Bmw();
     }
     
     public Car driveBenz(){
           return new Benz();
     }

    //....
}

//使用：欢迎暴发户出场.....
public class Magnate{
     public static void main(String[] args){
        try{
          Driver driver = new Driver();
          //告诉司机我今天坐奔驰                   
          Car car = driver.driveBenz();
          //下命令：开车                          
          car.drive();
          ...
         }
      }



4、第三种——静态工厂方法模式（简单工厂模式）
经过以上的改进，使得工厂类已经很完美了，但是还是美中不足。因为每一次创建实例需要使用工厂类时，都需要创建工厂类。此时可以使用静态工厂模式，将工厂方法设置为静态的。

Java代码  收藏代码

   1. public class Driver{ 
   2.      public static Car driveBmw(){ 
   3.            return new Bmw(); 
   4.      } 
   5.        
   6.      public static Car driveBenz(){ 
   7.            return new Benz(); 
   8.      } 
   9.  
  10.     //.... 
  11. } 
  12.  
  13. //使用：欢迎暴发户出场..... 
  14. public class Magnate{ 
  15.      public static void main(String[] args){ 
  16.         try{ 
  17.           //告诉司机我今天坐奔驰                     
  18.           Car car = driver.driveBenz(); 
  19.           //下命令：开车                            
  20.           car.drive(); 
  21.           ... 
  22.          } 
  23.       } 

public class Driver{
     public static Car driveBmw(){
           return new Bmw();
     }
     
     public static Car driveBenz(){
           return new Benz();
     }

    //....
}

//使用：欢迎暴发户出场.....
public class Magnate{
     public static void main(String[] args){
        try{
          //告诉司机我今天坐奔驰                   
          Car car = driver.driveBenz();
          //下命令：开车                          
          car.drive();
          ...
         }
      }



5、工厂方法模式中涉及的角色
   抽象工厂，具体工厂，抽象产品，具体产品。

6、工厂方法模式使用的前提

    * 有创建一批有相同接口对象的需求
    * 不想暴露太多类的细节给使用者，或者隐藏对象的创建工作
    * 产品的等级机构比较复杂，使用简单工厂模式可能会造成扩展性问题。
    * 当一个类不知道他必须创建的类的时候，或者一个类希望由他的子类制定他所创建的对象的时候。举个例子：系统框架使用抽象类定义，创建和维护对象之间的关系，但通常这些具体的类需要有客户端来具体化，对于框架无法知道具体子类的情况下，使用工厂模式来进行框架的开发维护。所以，工厂模式也被称作“虚拟构造器”


7、工厂方法模式的优点缺点
优点：

    * 优化了简单工厂模式，做到了“开-闭”原则。
    * 可以做到把具体的产品创建过程延迟的具体的子类工厂，使得基类工厂可以基于工厂方法创建的抽象对象工作。

缺点：

    * 暴露具体工厂，但多数情况这不会造成问题，尤其是对于虚拟构造器，就显得更加合理。



对于工厂方法模式子类创建的模式，有点让大家联想到模版模式，其主要区别是工厂方法模式主要目的是把创建工作推迟到子类，而模版模式则是把剩余的逻辑交给子类。这二者也可以结合起来使用。

评论

2 楼 BabyDuncan 2011-03-09  

仅此而已 写道

设计模式看了，但是忘得更快。 再来温习下，感谢楼主

1 楼 仅此而已 2011-03-09  

设计模式看了，但是忘得更快。 再来温习下，感谢楼主