在需要生成大量对象的时候，我也会用工厂模式，但是一直就没理解，它的具体优势在哪里。
看很多地方说在以后修改的时候会比较简单，但是没有实际体会，不太了解。能不能用简单的语言说一下。

占个沙发求大牛指导~~~

接口是实现多重继承的途径，而生成遵循某个接口对象得典型方式就是工程设计模式。我们在工厂对想上调用的是创建方法，而该工厂对象将生成接口的某个实现的对象，通过这种方法，我们的代码将可以完全与接口的实现分离，这就使得我们可以透明的将某个实现替换为另一个。

简单工厂模式的优点如下：

（1）工厂类含有必要的判断逻辑，可以决定在什么时候创建哪一个产品类的实例，客户端可以免除直接创建产品对象的责任，而仅仅“消费”产品；简单工厂模式通过这种做法实现了对责任的分割，它提供了专门的工厂类用于创建对象。

（2）客户端无需知道所创建的具体产品类的类名，只需要知道具体产品类所对应的参数即可，对于一些复杂的类名，通过简单工厂模式可以减少使用者的记忆量。

（3）通过引入配置文件，可以在不修改任何客户端代码的情况下更换和增加新的具体产品类，在一定程度上提高了系统的灵活性。

工厂模式就相当于创建实例对象的new，我们经常要根据类Class生成实例对象，如A a=new A(). 工厂模式也是用来创建实例对象的，可能多做一些工作，但会给你系统带来更大的可扩展性和尽量少的修改量。

类Sample为例,要创建Sample的实例对象:

Sample sample=new Sample();
可是，实际情况是，通常我们都要在创建sample实例时做点初始化的工作,比如赋值 查询数据库等

首先，我们想到的是，可以使用Sample的构造函数，这样生成实例就写成:

Sample sample=new Sample(参数);

但是，如果创建sample实例时所做的初始化工作不是象赋值这样简单的事，可能是很长一段代码，如果也写入构造函数中，那你的代码很难看了

初始化工作如果是很长一段代码，说明要做的工作很多，将很多工作装入一个方法中，相当于将很多鸡蛋放在一个篮子里，是很危险的，这也是有背于Java面向对象的原则，面向对象的封装(Encapsulation)和分派(Delegation)告诉我们，尽量将长的代码分派“切割”成每段，将每段再“封装”起来(减少段和段之间偶合联系性)，这样，就会将风险分散，以后如果需要修改，只要更改每段，不会再发生牵一动百的事情。

我们需要将创建实例的工作与使用实例的工作分开, 也就是说，让创建实例所需要的大量初始化工作从Sample的构造函数中分离出去。

你想如果有多个类似的类，我们就需要实例化出来多个类。这样代码管理起来就太复杂了。
这个时候你就可以采用工厂方法来封装这个问题。
不能再用上面简单new Sample(参数)。还有,如果Sample有个继承如MySample, 按照面向接口编程,我们需要将Sample抽象成一个接口.现在Sample是接口,有两个子类MySample 和HisSample

Sample mysample=new MySample();
Sample hissample=new HisSample();
采用工厂封装：

public class Factory{

　　public static Sample creator(int which){

　　//getClass 产生Sample 一般可使用动态类装载装入类。
　　if (which==1)
　　　　return new SampleA();
　　else if (which==2)
　　　　return new SampleB();

　　}

}

那么在你的程序中,如果要实例化Sample时.就使用

Sample sampleA=Factory.creator(1);


举个更实际的例子，比如你写了个应用，里面用到了数据库的封装，你的应用可以今后需要在不同的数据库环境下运行，可能是oracle,db2,sql server等，那么连接数据库的代码是不一样的，你用传统的方法，就不得不进行代码修改来适应不同的环境，非常麻烦，但是如果你采用工厂类的话，将各种可能的数据库连接全部实现在工厂类里面，通过你配置文件的修改来达到连接的是不同的数据库，那么你今后做迁移的时候代码就不用进行修改了。

1. 观察一下程序
   
2. view plain
   
3. 
   
4.     package com.zsc.everyday;  
   
5.       
   
6.     interface Fruit{  
   
7.         public void eat();  
   
8.     }  
   
9.     class Apple implements Fruit{  
   
10.         public void eat() {  
    
11.             System.out.println("吃苹果");  
    
12.         }  
    
13.     }  
    
14.     class Orange implements Fruit{  
    
15.         public void eat() {  
    
16.             System.out.println("吃橘子");  
    
17.         }  
    
18.     }  
    
19.     public class InterfaceCase01 {  
    
20.         public static void main(String[] args) {  
    
21.             Fruit f = new Apple();  
    
22.             f.eat();  
    
23.         }  
    
24.     }  
    
25. 
    
26. 
    
27. 相信大家很容易就可以看懂。这样的方式好不好？我们再来看看下面的代码：
    
28. view plain
    
29. 
    
30.     package com.zsc.everyday;  
    
31.       
    
32.     interface Fruit{  
    
33.         public void eat();  
    
34.     }  
    
35.     class Apple implements Fruit{  
    
36.         public void eat() {  
    
37.             System.out.println("吃苹果");  
    
38.         }  
    
39.     }  
    
40.     class Orange implements Fruit{  
    
41.         public void eat() {  
    
42.             System.out.println("吃橘子");  
    
43.         }  
    
44.     }  
    
45.     class Factory{  
    
46.         public static Fruit getIntence(String className){  
    
47.             Fruit f = null ;  
    
48.             if("apple".equals(className)){  
    
49.                 f = new Apple();  
    
50.             }  
    
51.             if("orange".equals(className)){  
    
52.                 f = new Orange();  
    
53.             }  
    
54.             return f ;  
    
55.         }  
    
56.     }  
    
57.     public class InterfaceCase01 {  
    
58.         public static void main(String[] args) {  
    
59.             Fruit f = null ;  
    
60.             f = Factory.getIntence("apple");  
    
61.             f.eat();  
    
62.         }  
    
63.     }  
    
64. 
    
65. 
    
66. 这样看起来似乎就好一点了。
    
67. 
    
68. 解决问题：其实这种开发模式叫做工厂模式。我么可以很快发现程序在接口和子类之间加入了一个过渡段，通过此过渡段取得接口的实例化对象。
    
69. 
    
70. 总结：其实上面两个程序运行的结果没什么区别，但是取得实例的过程却不大一样，因为接口对象的实例是通过工厂取得的，这样以后如果再有子类扩充，直接修改客户端就可以根据标记得到相应的实例，灵活性较高。

复制代码