工厂模式

1. 创建型设计模式总结: 创建型设计模式应该应用于那些"接口相对稳定但类型实体本身却经常面临需求变化"的场合。如果接口不稳定，创建型设计模式将无法设计；如果类本身变化不大，创建型设计模式也就没有必要。

2. 工厂模式定义：定义一个创建对象的接口，并让子类来决定由哪个类实现这个接口。工厂模式将接口实例化交给子类完成。

工厂模式是非常常见的模式，通常与动态类的加载相结合使用。常用的JDBC中，只返回一个Connection接口，而Connection的具体实现则由不同的数据库供应商来提供。对于工厂模式和抽象工厂，有必要多分析一下两者的区别，我也很久没有搞清楚。相似点：都把创建对象的工作交给了子类来做，自己只是提供一个接口。区别：工厂模式所要创建的对象相对来说非常简单，而且对象相互独立，没有联系。通常情况，只从一个工厂中取得一个对象，如LogManager.getLogger()；而抽象工厂是工厂模式的一种升级，它所要创建的对象复杂且相互关联（如不同的茶叶对于水温的要求不同），运用工厂模式很难保证对象的一致性且扩展性不好，这时就需要将这部分对象的创建提取出来，形成抽象工厂。

3. 用代码说明问题. (源代码有时胜过千言万语)：首先创建了一辆奔驰：Car car = new Benze();  突然我们的车变了，变成宝马了，Ok我修改一下：Car car = new BMW(); 设想一下在我们的代码中散布了无数这样的代码，那么当你以后需要换车的时候，是不是需要一一修改我们的创建代码把Benze改成BMW.然后我们再用工厂来实现一下:

1. public interface CarFactory {
2.     public Car createCar();
3.     public Car fixCar();
4.     public void recoveryCar();
5. }
6. public class BenzeFactory implements CarFactory {
7.     public Car createCar(){};
8.     public Car fixCar(){};
9.     public void recoveryCar(){};
10. }
11. public class BMWFactory implements CarFactory {
12.     public Car createCar(){};
13.     public Car fixCar(){};
14.     public void recoveryCar(){};
15. }
16. public class PeugeotFactory implements CarFactory {
17.     public Car createCar(){};
18.     public Car fixCar(){};
19.     public void recoveryCar(){};
20. }
21. public class VolvoFactory implements CarFactory {
22.     public Car createCar(){};
23.     public Car fixCar(){};
24.     public void recoveryCar(){};
25. }
26. public class CarDAOFactory {
27.     public static CarFactory getBenzeFactory() {
28.         return new BenzeFactory();
29.     }
30.     public static CarFactory getBMWFactory() {
31.         return new BMWFactory();
32.     }
33.     public static CarFactory getPeugeotFactory() {
34.         return new PeugeotFactory();
35.     }
36.     public static CarFactory getVolvoFactory() {
37.         return new VolvoFactory();
38.     }
39. }

当你需要换Car的时候你只需修改一处代码就是：CarFactory carFac = CarDAOFactory.getXXXFactory(); 其他创建车的地方,永远不变,还是：Car car = carFac.createCar();

或者可以直接这样使用：Car car = CarDAOFactory.getXXXFactory().createCar();

当程序不很复杂时，也可以删掉CarDAOFactory类：CarFactory carFac = new XXXFactory(); --> Car car = carFac.createCar();

同样，对于自行车也是如此：

1. public interface BicycleDAO {
2.     public Bicycle createBicycle();
3.     public Bicycle fixBicycle();
4.     public void recoveryBicycle();
5. }
6. public class MeridaDAOImpl implements BicycleDAO {
7.     public Bicycle createBicycle(){};
8.     public Bicycle fixBicycle(){};
9.     public void recoveryBicycle(){};
10. }
11. public class GiantDAOImpl implements BicycleDAO {
12.     public Bicycle createBicycle(){};
13.     public Bicycle fixBicycle(){};
14.     public void recoveryBicycle(){};
15. }
16. public class SpecializedDAOImpl implements BicycleDAO {
17.     public Bicycle createBicycle(){};
18.     public Bicycle fixBicycle(){};
19.     public void recoveryBicycle(){};
20. }
21. public class TrekDAOImpl implements BicycleDAO {
22.     public Bicycle createBicycle(){};
23.     public Bicycle fixBicycle(){};
24.     public void recoveryBicycle(){};
25. }
26. public class BicycleFactory {
27.     public static BicycleDAO getMeridaInstance() {
28.         return new MeridaDAOImpl();
29.     }
30.     public static BicycleDAO getGiantInstance() {
31.         return new GiantDAOImpl();
32.     }
33.     public static BicycleDAO getSpecializedInstance() {
34.         return new SpecializedDAOImpl();
35.     }
36.     public static BicycleDAO getTrekInstance() {
37.         return new TrekDAOImpl();
38.     }
39. }

你明白了吗? 我们很难避免修改，但是我们要尽量做到只修改一处。不知道这样的解释你是否满意。使用创建者模式是为了提高代码的可维护性(即应对未来修改的能力)。