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();
    }
}

总结：

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