Java工厂设计模式

1. 简单工厂

interface Car{}class BMWCar implements Car{    BMWCar(){        System.out.println("宝马车被制造了。。");    }}class AudiCar implements Car{    AudiCar(){        System.out.println("奥迪车被制造了。。");    }}public class SimpleCarFactory {    public static final int BMWCAR = 1;     public static final int AUDICAR = 2;     public static Car produceCar(int carType) throws Exception{        switch (carType) {        case BMWCAR:            return new BMWCar();        case AUDICAR:            return new AudiCar();        default:            throw new Exception("没有这种车");        }    }    public static void main(String[] args) {        try {            SimpleCarFactory.produceCar(SimpleCarFactory.BMWCAR);        } catch (Exception e) {            e.printStackTrace();        }    }}

上面的代码实现了一个简单工厂，传入需要制造的车的类型返回相应的实例，但是简单工厂存在许多缺陷，首先，添加新的车的种类的时候需要修改源代码。其次，也是最大的缺点就是整个系统全都依赖SimpleCarFactory,如果SimpleCarFactory类一旦出现问题，那么整个系统就变成了瘫痪状态。我们可以通过下面两种方式来谋求解决方案。

2. 工厂方法

重复代码我就不写了，看简单工厂代码interface Factory{    Car create();}class BMWCarFactory implements Factory{    @Override    public Car create() {        return new BMWCar();    }}class AudiCarFactory implements Factory{    @Override    public Car create() {        return new AudiCar();    }}public class TestFactory {    public static void main(String[] args) {        Factory factory = new BMWCarFactory();        factory.create();    }}

工厂方法有效的解决了上面简单工厂存在的问题，如果新加入一个车和一个车的工厂不需要更改源代码，而且如果一个工厂类出现了问题不会影响到其他工厂类的使用。

新添加一个车和工厂

class AUTOCar implements Car{    AUTOCar(){        System.out.println("奥拓车被制造了。。");    }}class AUTOCarFactory implements Factory{    @Override    public Car create() {        return new AUTOCar();    }}

目前为止已经解决了上面的问题，下面问题又来了，因为相同的车同样还有型号不同的时候，不同型号的车的配件各有不同，可以通过抽象工厂来解决。

3. 抽象工厂

interface Car{}abstract class BMWCar implements Car {}class BMWX3 extends BMWCar {    BMWX3() {        System.out.println("BMWX3车被制造了。。");    }}class BMWX5 extends BMWCar {    BMWX5() {        System.out.println("BMWX5车被制造了。。");    }}interface Chair{}class BMWX3Chair implements Chair{    BMWX3Chair() {        System.out.println("BMWX3的座椅被制造了。。");    }}class BMWX5Chair implements Chair{    BMWX5Chair() {        System.out.println("BMWX5的座椅被制造了。。");    }}interface Window{}class BMWX3Window implements Window{    BMWX3Window() {        System.out.println("BMWX3的车窗被制造了。。");    }}class BMWX5Window implements Window{    BMWX5Window() {        System.out.println("BMWX5的车窗被制造了。。");    }}interface Factory {    Car create();}abstract class BMWCarFactory implements Factory {    abstract Chair createChair();    abstract Window createWindow();}class BMWX3CarFactory extends BMWCarFactory{    @Override    public Car create() {        return new BMWX3();    }    @Override    Chair createChair() {        return new BMWX3Chair();    }    @Override    Window createWindow() {        return new BMWX3Window();    }}class BMWX5CarFactory extends BMWCarFactory{    @Override    public Car create() {        return new BMWX5();    }    @Override    Chair createChair() {        return new BMWX5Chair();    }    @Override    Window createWindow() {        return new BMWX5Window();    }}public class TestAbstractFactory {    public static void main(String[] args) {        BMWCarFactory factory = new BMWX3CarFactory();        factory.createWindow();        factory.createChair();        factory.create();    }}

总结：

无论是简单工厂模式，工厂方法模式，还是抽象工厂模式，他们都属于工厂模式，在形式和特点上也是极为相似的，他们的最终目的都是为了解耦。在使用时，我们不必去在意这个模式到底工厂方法模式还是抽象工厂模式，因为他们之间的演变常常是令人琢磨不透的。经常你会发现，明明使用的工厂方法模式，当新需求来临，稍加修改，加入了一个新方法后，由于类中的产品构成了不同等级结构中的产品族，它就变成抽象工厂模式了；而对于抽象工厂模式，当减少一个方法使的提供的产品不再构成产品族之后，它就演变成了工厂方法模式。
所以，在使用工厂模式时，只需要关心降低耦合度的目的是否达到了。