设计模式之抽象工厂

之前我们有提到，简单工厂存在工厂间耦合性太强的问题；工厂方法存在客户端代码复杂的问题。这两种设计模式都不够完美，因此出现了我们今天要介绍的抽象工厂设计模式。

好了，下面我们来写代码体验一下抽象工厂：

还是用之前我们用的面包类作为例子：

public interface Bread {
    void eat();
}

//此处的DanXiang为面包品牌
public class DanXiangBread implements Bread {
    @Override
    public void eat() {
        System.out.println("我在吃丹香面包");
    }
}

//此处的桃李为面包品牌
public class TaoLiBread implements Bread{
    @Override
    public void eat() {
        System.out.println("我在吃桃李面包");
    }
}

产品类写完了，下面我们来写工厂类：

首先我们建一个抽象工厂类：

public abstract class AbstractFactory {
    protected abstract Bread makeBread();
    
    public Bread makeBread(String bread) {
        switch (bread){
            case "TaoLi":
                return new TaoLiBreadFactory().makeBread();
            case "DanXiang":
                return new DanXiangBreadFactory().makeBread();
            default:
                System.out.println("sorry, 我们不生产这种面包");
                return null;
        }
    }
}

丹香面包工厂继承自抽象工厂，并重写了makeBread()方法：

public class DanXiangBreadFactory extends AbstractFactory {
    @Override
    protected Bread makeBread() {
        return new DanXiangBread();
    }
}

同样地，桃李面包工厂：

public class TaoLiBreadFactory extends AbstractFactory {
    @Overrid
    public Bread makeBread() {
        return new TaoLiBread();
    }
}

下面我们来写测试类代码，但是写到这里我们发现，因为抽象工厂AbstractFactory是一个抽象类，我们在这里没有办法new出它的实例，因此我们在这里新建一个抽象工厂类的子类DefaultFactory（貌似Spring就是采用这种方法，不过还没开始看Spring源码，以后再更新有关Spring的内容）。如果在测试类的makeBread()方法中制定了参数，那么就按参数来制造面包，否则，默认制造丹香面包。

public class DefaultFactory extends AbstractFactory{
    private DanXiangBreadFactory defaultFactory = new DanXiangBreadFactory();
    public Bread makeBread(){
        return defaultFactory.makeBread();
    }
}

测试类：

public class Test {
    public static void main(String[] args) {
        DefaultFactory defaultFactory = new DefaultFactory();
        Bread bread = defaultFactory.makeBread();
        Bread bread1 = defaultFactory.makeBread("TaoLi");
        bread.eat();
        bread1.eat();
    }
}

看到这里可能有的同学会有一个疑问，简单工厂和抽象方法同样是switch语句，那么为什么还要用抽象工厂？我们仔细思考一下，抽象方法的case后我们可能只需要 return new TaoLiBreadFactory().makeBread();就可以了；但是如果用简单工厂方法，case后跟的就是makeBread的具体步骤，在实际的工程中，不会像演示中的这样简单，这无疑会使代码混乱，从而不好维护。

我们可以看到，抽象工厂不同品牌的面包是不同的工厂生产的，解决了简单工厂存在的问题；客户端代码中不需要制定具体的工厂，解决了工厂方法存在的问题。

好了，我们可以看到，抽象工厂用的是组合的方法，而工厂方法用的是继承（或实现接口）。用工厂方法时创建对象时，需要扩展一个类，并覆盖它的工厂方法。