这次主要介绍的是三种与工厂有关的模式：简单工厂模式、工厂方法模式、抽象工厂模式。课件与源码点击这里。
不用工厂模式
这次我们以宝马车的生产来举例。当用户想要一辆宝马时，如果不用工厂，那么用户得自己先创造才能用：
车制造类：
public class BMW320 {
public BMW320() {
System.out.println("制造-->BMW320");
}
}
主方法：
public class WithoutFactory {
public static void main(String[] args) {
BMW320 bmw320 = new BMW320();
}
}
但是这样客户得自己生产宝马，客户得知道汽车的生产方法才行。但是现实生活都是由工厂来生产，客户只需要购买就可以，这样汽车的生产过程与用户就松耦合了。这样就引入了工厂模式。将车的生产过程都放在工厂中实现，用户只需传入想买的车即可。
简单工厂模式
下面看看简单工厂的写法：
定义一个BMW基类:
public class BMW {
public BMW() {
}
}
具体的汽车型号都继承自基类：
public class BMW320 extends BMW{
public BMW320() {
System.out.println("制造-->BMW320");
}
}
public class BMW523 extends BMW{
public BMW523(){
System.out.println("制造-->BMW523");
}
}
再建立一个工厂，通过用户传入的车的型号来生产汽车：
public class Factory {
public BMW createBMW(String type){
if (type.equals("BMW320")) {
return new BMW320();
}else if (type.equals("BMW523")){
return new BMW523();
}
return null;
}
}
最后是主方法：
public class SimpleFactory {
public static void main(String[] args) {
// TODO Auto-generated method stub
Factory factory = new Factory();
BMW bmw320 = factory.createBMW("BMW320");
}
}
简单工厂类的UML图如下：
但是在简单工厂模式中，如果要增加一种新的车型时，就需要在工厂类中增加相应的创建业务逻辑，如果增加的类型一多的话就会将工厂类变得臃肿，这时工厂方法模式出现了。
工厂方法模式
我们将每个车型都设置一个工厂，不同的工厂生产不同的车型。
工厂接口：
interface FactoryBWM {
public BMW createBMW();
}
具体汽车生产工厂：
public class FactoryBMW320 implements FactoryBWM{
@Override
public BMW createBMW() {
return new BMW320();
}
}
主方法：
public class FactoryMethod {
public static void main(String[] args) {
FactoryBWM factoryBWM320 = new FactoryBMW320();
factoryBWM320.createBMW();
FactoryBWM factoryBWM523 = new FactoryBMW523();
factoryBWM523.createBMW();
}
}
简单工厂模式算工厂方法模式的一种特殊情况。
抽象工厂模式
最后再介绍抽象工厂模式。前面两种介绍的是一系列产品的制造，而抽象工厂则是同一种产品的制造。可以理解为前两种是横向的，抽象工厂是纵向的。比如：还是造宝马，有的空调带暖风，有的只能吹冷风；有的座椅是真皮，有的座椅是格布。而一般带暖风的空调得配格布座椅，而带冷风的空调配真皮座椅。
-
空调：
interface Aircondition { // 空调 } public class AirconditionColdWind implements Aircondition{ public AirconditionColdWind() { System.out.println("空调有冷风了"); } } public class AirconditionWarmWind implements Aircondition{ public AirconditionWarmWind() { System.out.println("空调有暖风了"); } } -
座椅：
interface Sofa { // 沙发 } public class SofaOfGebb implements Sofa{ public SofaOfGebb(){ System.out.println("我的格布座椅"); } } public class SofaOfHypoderm implements Sofa{ public SofaOfHypoderm() { System.out.println("我的真皮座椅"); } } -
产品线：
interface AbstractProduce { public Aircondition createAircondition(); public Sofa createSofa(); } public class Condition1 implements AbstractProduce{ // 搭配方案1: 冷风搭真皮 @Override public Aircondition createAircondition() { return new AirconditionColdWind(); } @Override public Sofa createSofa() { return new SofaOfHypoderm(); } } public class Condition2 implements AbstractProduce{ // 搭配方案2: 暖风搭格布 @Override public Aircondition createAircondition() { return new AirconditionWarmWind(); } @Override public Sofa createSofa() { return new SofaOfGebb(); } } -
主方法：
public class AbstractFactory { public static void main(String[] args) { AbstractProduce customProduce = new Condition1(); customProduce.createAircondition(); customProduce.createSofa(); AbstractProduce customProduce2 = new Condition2(); customProduce2.createAircondition(); customProduce2.createSofa(); } }
当需要创建的对象是一系列相互关联或相互依赖的产品族时，便可以使用抽象工厂模式。
在使用时，我们不必去在意这个模式到底工厂方法模式还是抽象工厂模式，因为他们之间的演变常常是令人琢磨不透的。经常你会发现，明明使用的工厂方法模式，当新需求来临，稍加修改，加入了一个新方法后，由于类中的产品构成了不同等级结构中的产品族，它就变成抽象工厂模式了；而对于抽象工厂模式，当减少一个方法使的提供的产品不再构成产品族之后，它就演变成了工厂方法模式。所以，在使用工厂模式时，只需要关心降低耦合度的目的是否达到了。
