工厂模式

工厂模式的几种形态：
1、简单工厂模式，又叫做静态工厂方法（Static Factory Method）模式。
2、工厂方法模式，又称为多态性工厂(Polymorphic Factory)模式
3、抽象工厂模式，又称工具（Kit或ToolKit）模式

 

1.简单工厂模式是类的创建模式，又叫做静态工厂方法（Static Factory Method）模式。
它是由一个工厂对象决定创建出哪一种产品类的实例。

　　简单工厂模式的UML类图

　　简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类（这些产品类继承自一个父类或接口）的实例。

 

　　该模式中包含的角色及其职责

 

　　工厂（Creator）角色

 

　　简单工厂模式的核心，它负责实现创建所有实例的内部逻辑。工厂类可以被外界直接调用，创建所需的产品对象。

 

　　抽象（Product）角色

 

　　简单工厂模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。

 

　　具体产品（Concrete Product）角色

 

　　是简单工厂模式的创建目标，所有创建的对象都是充当这个角色的某个具体类的实例。

　　一般来讲它是抽象产品类的子类，实现了抽象产品类中定义的所有接口方法。

简单工厂模式的优点己缺点
  优点：模式的核心是工厂类，这个类有必要的判断逻辑，可以决定在什么时候创建哪一个产品类的实例。
        而客户端则可以免除直接创建产品对象的责任，而仅仅负责“消费”产品。简单工厂模式通过这种做法实现了对责任的分割
       
  缺点：1)这个工厂类集中了所有的产品创建逻辑，形成一个无所不知的全能类，有人把这种类叫做上帝类（God Class）。
          如果这个全能类代表的是农场的一个具体园丁的话，那么这个园丁就需要对所有的产品负责，成了农场的关键人物，
          他什么时候不能正常工作了，整个农场都要受到影响；
         
        2)将这么多的逻辑集中放在一个类里面的另外一个缺点是，当产品类有不同的接口种类时，工厂需要判断在什么时候创建某种产品，
          这种对时机的判断和对哪一种具体产品的判断逻辑混合在一起，使得系统在将来进行功能扩展时较为困难。
          这一缺点在工厂方法模式中得到克服
       
        3）由于简单工厂模式使用静态方法作为工厂反尬，而静态方法无法由子类继承，因此工厂角色无法形成基于继承的等级结构。
           这一缺点会在工厂方法模式中得到克服
s

2.工厂方法模式属于创建模式，也是关于如何创建对象的模式。

2.1 是对简单工厂模式的改进。简单模式中工厂处于核心位置，对于复杂的层次对象显得过于复杂，缺乏扩展性。即做不到“开-闭”原则。如果有新产品加入到系统，需要须改工厂，加入创建逻辑。工厂模式则巧妙的避开了这点，并且把创建责任推迟到子类。

另外，工厂方法的这个技术 ( 虚拟创建推迟到子类 ) 对开发系统框架非常有用。

2.2 工厂模式是：定义一个用于创建对象的接口，让子类决定实例化哪一个类，使一个类的实例化延迟到子类。
它有个特点，就是通常工厂的类层次与产品的类层次几乎是一样的树。如果说工厂是你的影子，你就是产品了。在你平时未用到模式的时候，你需要什么就new一个，这种情况就好比你躺在地上，人影合一了。那什么时候需要工厂模式呢。看看定义：“使一个类的实例化延迟到子类”，这个是关键，当你有必要延迟实例化的时候才需要用工厂模式。那什么情况下要延迟呢，在单例模式中有惰性单例（就是单例那个静态属性）……等等，就是一开始你还不适合立刻就创建该对象，你还需要一些资源或其它准备工作。整个系统的运行不像单个程序那样，系统需要很多资源和多方面的协同工作。

为什么工厂模式是如此常用？因为工厂模式就相当于创建实例对象的new，我们经常要根据类Class生成实例对象，如A a=new A() 工厂模式也是用来创建实例对象的，所以以后new时就要多个心眼，是否可以考虑实用工厂模式，虽然这样做，可能多做一些工作，但会给你系统带来更大的可扩展性和尽量少的修改量。

3.抽象工厂

抽象工厂是：提供一个创建一系列相关或相互依赖对象的接口，而无虚指定他们的具体类。
抽象工厂比工厂模式复杂的多。如果楼主说他们像可能是他们都叫工厂，都生成产品，都是接口型设计模式。但是我觉得他们是两个不同的设计模式。首先他们的目的是不同的。工厂是为了“延迟创建”，而抽象工厂是提供一系列的接口，是为了组织创建对象的灵活性，避免重复，避免耦合低内聚。
设计模式本身语言晦涩难懂，这个抽象工厂我也是没次都看着头昏眼花^_^,举个运用他的场景：
1。你有两台单色打印机，一台黑白墨的，一台彩墨的。
2。你有两种文件要打，一种讲演搞，一种图片
3。要求是讲演稿如果是有图就打黑白的，没图打彩色的，照片有字的就打黑白的，没字就打彩色的。

Java代码

1. class Print{   
2. ……   
3.     void doTalk(){   
4.        if(flag)   
5.            //color            1   
6.        else  
7.            //non-color        2   
8.    }   
9.   
10.    void doPicture(){   
11.        if(flag)   
12.           //color             3   
13.        else  
14.           //non-color         4   
15.    }   
16. ……   
17. }  

class Print{
……
    void doTalk(){
       if(flag)
           //color            1
       else
           //non-color        2
   }

   void doPicture(){
       if(flag)
          //color             3
       else
          //non-color         4
   }
……
}

上面的这个场景就是可以运用抽象工厂来重构的。

public abstract class AbsFactory{
    abstract TalkPrint getTalkPrint(); //打讲演稿
    abatract PicPrint getPicPrint();   //打图片的
}

public class ColorFactory extends AbsFactory{
    TalkPrint getTalkPrint(){
       //彩色讲演稿打印
    }

    PicPrint getPicPrint(){
       //彩色图片打印
    }
}

public class NonColorFactory extends AbsFactory{
    TalkPrint getTalkPrint(){
         //黑白讲演稿打印
    }

    PicPrint getPicPrint(){
         //黑白图片打印
    } 
}

public abstract class TalkPrint{
   //抽象的讲演稿打印
}

public class colorTalkPrint extends TalkPrint{
   //彩色讲演稿打印
}

public class noncolorTalkPrint extends TalkPrint{
   //黑白讲演稿打印
}

public abstract class PicPrint{
   //抽象的图片打印
}


public class colorPicPrint extends PicPrint{
   //彩色图片打印
}

public class noncolorPicPrint extends PicPrint{
   //黑白图片打印
}

进一步解释这个场景，就是当你做相似的工作又多种选择的时候，可以考虑用抽象工厂。

这里你要打印各种文件是一组相似的工作，打印有彩色、黑白等针对打印的不同要求。


这里仅仅举了一个方面的例子。

我们可以看出，虽然抽象工厂和工厂在代码形式上很相似，甚至抽象工作可以有工厂来拓展，但是他们的出发点是不一样的。

在搞单例模式的时候我们针对多线程拓展了为“双重检查模式”，那是同一个场景同一个任务，跟这里是不一样的