Java设计模式之工厂模式

1.引入

提到工厂，我们都知道，工厂生产产品。我们从语义中可以提取出两个名词：工厂、产品。有的工厂是单产品系列的，比如我有个工厂，我就只生产小汽车：A型号的，B型号的，C型号的等等。而有的工厂什么都生产，比如我除了生产小汽车，我还生产公交车，公交车的型号可能和小汽车一样，A型号，B型号，C型号。也可能不一样，比如我就只有A型号。再有可能，我A型号、B型号、C型号都没有，就只有D型号。所以我们可以总结出四类情况：

（1）一种产品，多个型号

（2） 两种产品，型号相同

（3）两种产品，型号部分相同

（4）两种产品，型号完全不同

就产品系列而言，我们可以将工厂模式分为简单工厂、工厂和抽象工厂。其中，简单工厂模式和工厂模式都适用于单系列产品，抽象工厂模式用于多系列产品。额

2.代码分析

  就简单工厂模式、工厂模式和抽象工厂模式分别展开论述。

2.1 简单工厂模式

package com.lcy.test;
//提供一个产品接口
public interface iCar {
    public void style();
}


package com.lcy.test;
//A型小汽车类
public class AStyleCar implements iCar{
	@Override
	public void style() {
		System.out.println("A型小汽车");
	}
}


package com.lcy.test;
//B型小汽车类
public class BStyleCar implements iCar{
	@Override
	public void style() {
		System.out.println("B型小汽车");
	}
}


package com.lcy.test;
//C型小汽车类
public class CStyleCar implements iCar{
	@Override
	public void style() {
		System.out.println("C型小汽车");
	}
}


package com.lcy.test;//生产产品的工厂类public class CarFactory {​	private static int A_MARK = 1;	private static int B_MARK = 2;	private static int C_MARK = 3;	public static Object createCar(int mark) {	    iCar car=null;		if (A_MARK == mark) {			car = new AStyleCar();		} else if (B_MARK == mark) {			car = new BStyleCar();		} else if (C_MARK == mark) {			car = new CStyleCar();		}		return car;	}}package com.lcy.test;//测试类public class CarTest {​	public static void main(String[] args) {		iCar car = (iCar) CarFactory.createCar(1);		car.style();	}}

对以上代码进行分析，可以知道简单工厂模式的创建步骤：

（1）抽象产品接口：如iCar

（2）具体的产品子类：如AStyleCar、BStyleCar、CStyleCar。

（3）工厂类：如CarFactory。该类是一个具体的类，类中有个静态方法，可以不用创建类实例，直接调用静态方法。所以简单工厂模式也被称为静态工厂模式。

从上面的代码中我们可以很容易看出不足的地方，工厂类代码写死了。如果我们要增加一个D型小汽车。产品类可以直接扩展，直接创建个类DStyleCar实现接口即可。但是我们必须得动工厂类中的代码。如此就不好了。

以下我们通过工厂模式对上面的问题进行改造。

2.2 工厂模式

package com.lcy.test02;
import com.lcy.test.iCar;
//抽象工厂类
public abstract class AbstratctFactory {
    public abstract iCar create();
}

package com.lcy.test02;
import com.lcy.test.AStyleCar;
import com.lcy.test.iCar;
//工厂类具体实现AbstractACar
public class AbstractACar extends AbstratctFactory{@Overridepublic iCar create() {return new AStyleCar();}}

package com.lcy.test02;
import com.lcy.test.AStyleCar;
import com.lcy.test.BStyleCar;
import com.lcy.test.iCar;
//工厂类具体实现AbstractBCarpublic class AbstractBCar extends AbstratctFactory{@Overridepublic iCar create() {return new BStyleCar();}}

package com.lcy.test02;
import com.lcy.test.CStyleCar;
import com.lcy.test.iCar;
//工厂类具体实现AbstractCCar
public class AbstractCCar extends AbstratctFactory{@Overridepublic iCar create() {return new CStyleCar();}}

package com.lcy.test02;

//测试类
public class CarTest {
	public static void main(String[] args) {
		AbstractACar abstractACar=new AbstractACar();
		abstractACar.create().style();
	}
}

从以上代码可以看出，工厂模式将简单工厂模式中的 工厂类 设计为抽象类，然后增加具体的实现类。这样的话，易于我们扩展。比如，新增了D型小汽车，我们可以增加其具体的实现类。关于产品类的设计和简单工厂模式是一致的。

对工厂模式的编制步骤总结：

（1）抽象产品接口：如 iCar

（2）具体的产品子类：如 AStyleCar  BStyleCar  CStyleCar

（3）抽象工厂类：类里面有一个重要的抽象方法。

（4）具体的工厂子类

2.3 抽象工厂模式

package com.lcy.test03;
//抽象产品接口
public interface iCar {
    public void showStyle();
}

package com.lcy.test03;
//产品实现类A
public class ACar implements iCar{
	@Override
	public void showStyle() {
       System.out.println("A型小汽车");		
	}
}

package com.lcy.test03;
//产品实现类B
public class BCar implements iCar{
	@Override
	public void showStyle() {
        System.out.println("B型小汽车");		
	}
}

package com.lcy.test03;
//产品实现类C
public class CCar implements iCar{
	@Override
	public void showStyle() {
       System.out.println("C型小汽车");		
	}
}

//多产品系类  就类似上面增加一个产品：比如 公交车

package com.lcy.test03;
public interface iBus {
    public void showStyle();
}

package com.lcy.test03;

public class ABus implements iBus{
	@Override
	public void showStyle() {
       System.out.println("A型公交車");		
	}
}

package com.lcy.test03;

public class BBus implements iBus{
	@Override
	public void showStyle() {
        System.out.println("B型公交車");		
	}
}

package com.lcy.test03;

public class CBus implements iBus{
	@Override
	public void showStyle() {
       System.out.println("C型公交車");		
	}
}

//一个抽象工厂类
package com.lcy.test03;

public abstract class AbstractFactory {
  public abstract iCar createCar();
  public abstract iBus createBus();
}

//工厂实现类A
package com.lcy.test03;

public class AbstractFactoryA extends AbstractFactory{
	@Override
	public iCar createCar() {
		return new ACar();
	}
	@Override
	public iBus createBus() {
		return new ABus();
	}
}
//工厂实现类B 
package com.lcy.test03;

public class AbstractFactoryB extends AbstractFactory{
	@Override
	public iCar createCar() {
		return new BCar();
	}
	@Override
	public iBus createBus() {
		return new BBus();
	}
}
//工厂实现类C
package com.lcy.test03;

public class AbstractFactoryC extends AbstractFactory{
	@Override
	public iCar createCar() {
		return new CCar();
	}
	@Override
	public iBus createBus() {
		return new CBus();
	}
}

工厂生产多个产品，每个产品的特征都一样的话，实现方式如以上代码。那么，如果不同的产品有部分特征相同或是完全不同的话该怎么实现？

最重要的就是抽象工厂类，这个类里面定义了两个抽象方法，作为它的实现类，就必须重写这两个方法。这就相当于把两个产品绑死了。那怎么办？对，将两个产品分开。设置两个抽象工厂类，分别实现。但是感觉类的数量瞬间膨胀了一倍。还有一种方法就是抽象工厂类里面不给定抽象方法，由子类自由实现。