设计模式初探-工厂方法模式(Factory Method)

工厂方法模式，Factory Method，属于对象创建型模式，通过定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method使一个类的实例化延迟到其子类。工厂方法通过抽象的接口，将创建对象的行为交给具体的子类。

一、使用场景

1、当一个类不知道它所必须创建的对象的类的时候，由于不知道要创建对象的类，所以不能直接实例化类，只能交给其他知道该类的类去做，比如某接口的具体实现，某父类的子类。

2、当一个类希望由它的子类来指定它所创建的对象，这一般发生在父类不清楚具体实例化哪个类的时候。

3、当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类时代理者这一信息局部化的时候。

二、UML图

三、Java实现

[java]  view plain copy

1. package study.patterns.factorymethod;  
2. /** 
3.  * 工厂方法模式： 
4.  * 核心工厂类不再负责所有产品的创建， 
5.  * 而是将具体创建的工作交给子类去做， 
6.  * 自己则成为一个抽象工厂角色， 
7.  * 仅负责给出具体工厂类必须实现的接口， 
8.  * 而不接触哪一个产品类应当被实例化这种细节。 
9.  * @author qbg 
10.  */  
11. public class FactoryMethodPattern {  
12.         /** 
13.          * 产品类抽象:自行车 
14.          */  
15.         abstract class Bike{  
16.             public void ride(){}  
17.         }  
18.         /** 
19.          * 产品实现类：捷安特自行车  
20.          */  
21.         class GaintBike extends Bike{  
22.             public void ride(){  
23.                 System.out.println("Riding the Gaint Bike...");  
24.             }  
25.         }  
26.         /** 
27.          * 产品实现类：美利达自行车时 
28.          */  
29.         class MeridaBike extends Bike{  
30.             public void ride(){  
31.                 System.out.println("Riding the Merida Bike...");  
32.             }  
33.         }  
34.         /** 
35.          * 工厂抽象类  
36.          */  
37.         interface IFactory{  
38.             /** 
39.              * 工厂方法 
40.              */  
41.             public Bike createBike();  
42.         }  
43.         /** 
44.          * 捷安特自行车工厂  
45.          */  
46.         class GaintBikeFactory implements IFactory{  
47.             @Override  
48.             public Bike createBike() {  
49.                 return new GaintBike();  
50.             }  
51.         }  
52.         /** 
53.          * 美利达自行车工厂  
54.          */  
55.         class MeridaBikeFactory implements IFactory{  
56.             @Override  
57.             public Bike createBike() {  
58.                 return new MeridaBike();  
59.             }  
60.         }  
61.           
62.         public static void main(String[] args) {  
63.             FactoryMethodPattern fm = new FactoryMethodPattern();  
64.             //去捷安特自行车厂要辆捷安特骑骑  
65.             IFactory factory = fm.new GaintBikeFactory();  
66.             Bike gaint = factory.createBike();  
67.             gaint.ride(); //爽歪歪  
68.             //去美利达自行车厂要辆勇士600骑骑  
69.             factory = fm.new MeridaBikeFactory();  
70.             Bike merida = factory.createBike();  
71.             merida.ride();   
72.         }  
73. }  

四、模式优缺点

优点：

1、工厂方法不再将与特定应用有关的类绑定到你的代码中。比如示例中具体的自行车实现，在客户代码中只需要使用具体的工厂和自行车的抽象就完成了操作，而无需关心具体的自行车是什么牌的，长什么样子的。

2、为子类提供hook，任何时候想要更换产品的实现都可以。

3、连接平行的类层次，这一般用于工具性质的工厂方法。

缺点:

1、一个具体的产品实现就要绑定一个相应的工厂方法实现，如果用户只是为了创建一个特定的ConcreteProduct实例，就不得不创建Creator的子类。

转载于：http://blog.csdn.net/qbg19881206/article/details/17654721