1、引言
工厂模式可以分为类：
1）简单工厂模式（Simple Factory）
2）工厂方法模式（Factory Method）
3）抽象工厂模式（Abstract Factory）
这种模式从上到下逐步抽象，并且更具一般性，且通常将简单工厂模式看为工厂方法模式的一种特例，两者归为一类。
2、区别
工厂方法模式：
一个抽象产品类，可以派生出多个具体产品类。
一个抽象工厂类，可以派生出多个具体工厂类。
每个具体工厂类只能创建一个具体产品类的实例。
抽象工厂模式：
多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。
一个抽象工厂类，可以派生出多个具体工厂类。
每个具体工厂类可以创建多个具体产品类的实例。
总结：
工厂方法模式只一个抽象产品类，而抽象工厂模式有多个。
工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。
3、示例
1）简单工厂模式
产品类：
public class BMW {
public BMW() {
}
}
public class BMWX1 extends BMW {
public BMWX1() {
System.out.println("this is BMW X1");
}
}
public class BMWX7 extends BMW {
public BMWX7() {
System.out.println("this is BMW X7");
}
}
工厂类：
public class BMWFactory {
public BMW creatBMW(String type){
if (type.equals("X1")) {
return new BMWX1();
} else if (type.equals("X7")) {
return new BMWX7();
} else {
return null;
}
}
}
客户类：
public class Customer {
public static void main(String[] args) {
BMWFactory factory = new BMWFactory();
BMW X1 = factory.creatBMW("X1");
BMW X7 = factory.creatBMW("X7");
}
}
每增加一种车型，需增加一个if-else条件语句，违反了对扩展开放，对修改关闭原则
2）工厂方法模式：
产品类：
public class BMW {
public BMW() {
}
}
public class BMWX1 extends BMW {
public BMWX1() {
System.out.println("BMW X1");
}
}
public class BMWX7 extends BMW {
public BMWX7() {
System.out.println("BMW X7");
}
}
工厂类：
public interface BMWFactory {
BMW createBMW();
}
public class BMWX1Factory implements BMWFactory {
@Override
public BMW createBMW() {
return new BMWX1();
}
}
public class BMWX7Factory implements BMWFactory {
@Override
public BMW createBMW() {
return new BMWX7();
}
}
客户类：
public class Customer {
public static void main(String[] args) {
BMWX1Factory x1 = new BMWX1Factory();
x1.createBMW();
BMWX7Factory x7 = new BMWX7Factory();
x7.createBMW();
}
}
客户程序中仅仅处理抽象产品角色提供的接口，但使得对象的数量成倍增长。当产品种类非常多时，会出现大量的与之对应的工厂对象。
3）抽象工厂模式：
产品类：
public interface Engine {
}
public class EngineA implements Engine {
public EngineA() {
System.out.println("Engine A");
}
}
public class EngineB implements Engine {
public EngineB() {
System.out.println("Engine B");
}
}
public interface AirCondition {
}
public class AirConditionC implements AirCondition {
public AirConditionC() {
System.out.println("AirCondition C");
}
}
public class AirConditionD implements AirCondition {
public AirConditionD() {
System.out.println("AirCondition D");
}
}
工厂类：
public interface Abstractfactory {
public Engine selectEngine();
public AirCondition selectAirCondition();
}
public class FactoryBMWX1 implements Abstractfactory {
@Override
public Engine selectEngine() {
return new EngineA();
}
@Override
public AirCondition selectAirCondition() {
return new AirConditionC();
}
}
public class FactoryBMWX7 implements Abstractfactory{
@Override
public Engine selectEngine() {
return new EngineB();
}
@Override
public AirCondition selectAirCondition() {
return new AirConditionD();
}
}
客户类：
public class Customer {
public static void main(String[] args) {
FactoryBMWX1 x1 = new FactoryBMWX1();
x1.selectEngine();
x1.selectAirCondition();
FactoryBMWX7 x7 = new FactoryBMWX7();
x7.selectEngine();
x7.selectAirCondition();
}
}
提供多个工厂角色分别对应多个产品角色，每一个具体工厂角色只负责某一个产品角色的实例化，每一个具体工厂类只负责创建抽象产品的某一个具体子类的实例。
4、总结
无论是哪种工厂模式，在形式和特点上也是极为相似的，最终目的都是为了解耦。在使用时，不必在意具体属于哪种模式，因为他们之间的演变常常是令人琢磨不透的。经常你会发现，明明使用的工厂方法模式，当新需求来临，稍加修改，加入了一个新方法后，由于类中的产品构成了不同等级结构中的产品族，它就变成抽象工厂模式了；而对于抽象工厂模式，当减少一个方法使的提供的产品不再构成产品族之后，它就演变成了工厂方法模式。