常见设计模式之【工厂模式】

简介

工厂模式主要是为创建对象提供了接口。工厂模式按照《Java与模式》中的提法分为三类：

1. 简单工厂模式(Simple Factory)

2. 工厂方法模式(Factory Method)

3. 抽象工厂模式(Abstract Factory)

这三种模式从上到下逐步抽象，并且更具一般性。还有一种分类法，就是将简单工厂模式看为工厂方法模式的一种特例，两个归为一类。下面是使用工厂模式的两种情况：

1.在编码时不能预见需要创建哪种类的实例。

2.系统不应依赖于产品类实例如何被创建、组合和表达的细节

例子：

如果生活中有两种灯一种是灯泡，另一种是灯管，它们都有个方法发亮shine(),有两个人，一个人会做灯泡，一个人会做灯管，他们两个各自做各自的。如果我要订两批灯一批是灯泡一批是灯管的话。那我要分别派人去找两个人分别谈判、沟通两次，再分别派人取货，但有一天我派去取货的人喝醉了，去做灯泡的人那里去要灯管，又去做灯管的人那里取灯泡，这样可就出错了。后来这两个人合做开了一家灯工厂，拥有两条生产线，这个工厂能同时造灯泡和灯管，那我只需与这家工厂谈判一次就可以了，也只需派人来这个工厂的销售部取货就可以了。当然销售部不能只销售灯泡，也不能只销售灯管，是二者都销售，根据订单不同销售的内容也不同。

一、简单工厂模式

1>工厂类角色：SimpleFactory这是本模式的核心，含有一定的商业逻辑和判断逻辑。在java中它往往由一个具体类实现。

2>抽象产品角色：Light 它一般是具体产品继承的父类或者实现的接口。在java中由接口或者抽象类来实现。

3>具体产品角色：bulb和tube厂类所创建的对象就是此角色的实例。在java中由一个具体类实现。

abstract class Light{
  public abstract void shine();
}
class BulbLight extends Light{
  public void shine(){
   	System.out.println("Bulb Light is shine");
  }
}

class TubeLight extends Light{
  public void shine(){
   System.out.println("Tube Light is thrn on"); 
  }
}

class SimpleFactory{
public static Light creator(String name){
    if(name.equal("Bulb")){
         return new BulbLight();
    }else if(name.equal("Tube")){
         return new TubeLight();
    }
}
}
public class Test{
 public static void main(String[] args){
    SimpleFactory sf=new SimpleFactory();
    Light bulb=sf.creator("Bulb");
    bulb.shine();
    Light tube=sf.creator("Tube");
    tube.shine();
 }
}

二、工厂方法模式

1>抽象工厂角色：Light中这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现

2>具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。在java中它由具体的类来实现。

3>抽象产品角色：Light它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。

3>具体产品角色：bulb和tube具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。

public class Test{
 public static void main(String[] args){
    IFactoryLight factory =new FactoryLight();
    Light light=factory.createLight("BulbLight");
    light.shine();
 }
}

interface IFactoryLight{  
	public Light createLight(String name);
}
class FactoryLight implements IFactoryLight{
   @Override
   public Light createLight(String name){
        if(name.equals("BulbLight")){
	    return new BulbLight();	
	}else if(name.equals("TubeLight")){
	    return new TubeLight();	
	}  
		return null;
   }
}

interface Light{
  public void shine();
}
class BulbLight implements Light{
  public void shine(){
   	System.out.println("Bulb Light is shine");
  }
}

class TubeLight implements Light{
  public void shine(){
   	System.out.println("Tube Light is shine"); 
  }
}

三、抽象工厂模式

例子：

如果上面例子中要生产一种新产品－探照灯，那就得把原来的两条生产线进行大的修改，生产完成后再把生产线改回来，这样就太影响工作了，于是他们想出了一个方法再建一条生产线，专门生产探照灯。

1>抽象工厂角色：Creator是工厂方法模式的核心，与应用程序无关。任何在模式中创建的对象的工厂类必须实现这个接口。

2>具体工厂角色：BulbCreator与TubeCreator这是实现抽象工厂接口的具体工厂类，包含与应用程序密切相关的逻辑，并且受到应用程序调用以创建产品对象。

3>抽象产品角色：Light工厂方法模式所创建的对象的超类型，也就是产品对象的共同父类或共同拥有的接口。

4>具体产品角色：bulb和tube这个角色实现了抽象产品角色所定义的接口。某具体产品有专门的具体工厂创建，它们之间往往一一对应

/**
 * 抽象工厂模式
 * @author potter
 */
public class Test{
 public static void main(String[] args){
	BulbFactory bulbFactory=new BulbFactory();
	TubeFactory tubeFactory=new TubeFactory();
    BulbLight bulb=(BulbLight) bulbFactory.create();
    bulb.shine();
    TubeLight tube=(TubeLight) tubeFactory.create();
    tube.shine();
 }
}

interface Light{
  public abstract void shine();
}
class BulbLight implements Light{
  public void shine(){
   	System.out.println("Bulb Light is shine");
  }
}

class TubeLight implements Light{
  public void shine(){
   	System.out.println("Tube Light is shine"); 
  }
}

abstract class Factory{
  public abstract Light create();
}

class BulbFactory extends Factory{
  public Light create(){
     return new BulbLight();
  }
}

class TubeFactory extends Factory{
  public Light create(){
     return new TubeLight();
  }
}

这是我对工厂模式在java中的理解，欢迎各位来点评，指正说的不准确或者有误的地方，也欢迎大家对说的不全来进行补充

参考文章：

http://baike.baidu.com/view/1306799.htm

http://hi.baidu.com/grayworm/blog/item/4a832160f8c9de46eaf8f8c1.html

http://blog.csai.cn/user1/25929/archives/2009/35622.html