设计模式之工厂方法与抽象工厂

简单工厂

问题

我是一个电脑城老板，并且有一家小工厂，主要用来制造华为电脑和苹果电脑，也就是销售这两款电脑。顾客来购买电脑，我该如何实现呢？

解决代码

public class ComputerFactory {

    private static final String HUAWEI_TYPE = "huawei";

    private static final String APPLE_TYPE = "apple";

    public Computer produceComputer(String type) {
        switch (type) {
            case HUAWEI_TYPE:
                return new HuaweiComputer();
            case APPLE_TYPE:
                return new AppleComputer();
            default:
                System.out.println("无法识别的电脑品牌");
                return null;
        }
    }
}

public interface Computer {


    /**
     * 玩电脑
     */
    void play();
}

public class HuaweiComputer implements Computer {
    @Override
    public void play() {
        System.out.println("i am playing huawei computer");
    }
}

public class AppleComputer implements Computer {

    @Override
    public void play() {
        System.out.println("i am playing apple computer");
    }
}

来看执行代码：

    public static void main(String[] args) {
        // here comes a customer, want to buy huawei computer
        String customerHope = "huawei";
        // i tell my factory to produce huawei computer
        ComputerFactory computerFactory = new ComputerFactory();
        Computer computer = computerFactory.produceComputer(customerHope);
        //customer plays computer
        computer.play();
    }

执行结果：

i am playing huawei computer

总结

简单工厂不是一个设计模式，只是为了引入工厂方式模式的引子。其优点就是将创建对象过程隐藏，并且创建与使用分离。缺点：如果未来需要增加更多的电脑类型的话，produceComputer()会变得越来越臃肿和复杂。那么如何解决此问题呢，就需要引入接下来的工厂方法模式。

工厂方法模式

问题

随着我这个电脑城生意越做越大，我的小工厂一会要做华为电脑，一会要做苹果电脑，渐渐开始供不应求了，那么我就想多建一个工厂来生产电脑来保证供货，当然从理论上来说，一个工厂制造华为电脑，一个工厂制造苹果电脑的效率是会比两个工厂两种电脑都制造的效率来得高，并且成本会低。这就是单一职责原则。

解决代码

public interface ComputerFactory {

    Computer produceComputer();
}

public class AppleComputerFactory implements ComputerFactory {

    @Override
    public Computer produceComputer() {
        return new AppleComputer();
    }
}

public class HuaweiComputerFactory implements ComputerFactory {
    @Override
    public Computer produceComputer() {
        return new HuaweiComputer();
    }
}

执行代码：

    public static void main(String[] args) {
        // here comes a customer, want to buy huawei computer
        String customerHope = "huawei";
        // i tell my huawei computer factory to produce huawei computer
        HuaweiComputerFactory huaweiComputerFactory = new HuaweiComputerFactory();
        Computer computer = huaweiComputerFactory.produceComputer();
        //customer plays computer
        computer.play();
    }

执行结果：

i am playing huawei computer

总结

优点：

1. 避免创建者和具体产品之间的紧密耦合
2. 单一职责：可以将产品创建代码放在程序的单一位置， 从而使得代码更容易维护
3. 无需更改现有客户端代码，你就可以在程序中引入新的产品类型

缺点: 需要引入许多新的子类， 代码可能会因此变得更复杂。

相较于简单工厂，更侧重2，3两个优点。

抽象工厂模式

问题

我多增加了一个工厂，产量上来了，赚的资本越来越多，就不仅满足于只卖电脑赚钱了。我决定开始涉足其他产品，移动互联网时代，手机越来越火，那我就再生产手机来卖吧。就先制造华为和苹果手机来卖卖看。我暂时不想新增工厂来制造手机，那么就基于原来的工厂，增加一条流水线吧。

解决代码

首先增加流水线, 改造两个工厂

public interface Factory {

    Mobile produceMobile();


    Computer produceComputer();

}

public class AppleFactory implements Factory {

    @Override
    public Mobile produceMobile() {
        return new AppleMobile();
    }

    @Override
    public Computer produceComputer() {
        return new AppleComputer();
    }
}

public class HuaweiFactory implements Factory {

    @Override
    public Mobile produceMobile() {
        return new HuaweiMobile();
    }

    @Override
    public Computer produceComputer() {
        return new HuaweiComputer();
    }
}

增加产品：

public interface Mobile {

    /**
     * 玩手机
     */
    void play();
}

public class AppleMobile implements Mobile{

    @Override
    public void play() {
        System.out.println("i am playing apple mobile");
    }
}


public class HuaweiMobile implements Mobile {
    @Override
    public void play() {
        System.out.println("i am playing huawei mobile");
    }
}

执行代码:

    public static void main(String[] args) {
        //here comes a customer want to buy huawei mobile and huawei computer
        String guestHope = "i want buy huawei product";

        // i tell my huawei factory to produce huawei product
        Factory factory = new HuaweiFactory();
        Computer computer = factory.produceComputer();
        Mobile mobile = factory.produceMobile();
        computer.play();
        mobile.play();

        //here comes a customer want to buy huawei mobile and apple computer
        String guestHope1 = "i want buy huawei mobile and apple computer";
        Factory factory1 = new HuaweiFactory();
        Factory factory2 = new AppleFactory();
        Mobile mobile1 = factory1.produceMobile();
        Computer computer1 = factory2.produceComputer();
        computer1.play();
        mobile1.play();
    }

执行结果：

i am playing huawei computer
i am playing huawei mobile
i am playing apple computer
i am playing huawei mobile

总结

抽象工厂模式可以理解为工厂方法的升维，工厂方法的工厂只能生产一种产品，而抽象工厂可以生产多种不同类型产品。所以其优缺点基本和工厂方法模式一致。另外多的优点就是同一工厂生成的产品相互匹配。

总结

学习完工厂模式，就能很清晰的感觉到从简单工厂—>工厂方法—>抽象工厂，就是一个工厂从小慢慢做大的过程。回归到设计模式的定义：描述了在软件设计过程中的一些不断重复发生的问题，以及该问题的解决方案。工厂模式解决的问题就是工厂慢慢扩大工程中遇到的问题，这是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。

学习设计模式，一定要结合实际案例去理解，否则的话，设计模式就是个悬之高阁的理论，而很难去应用到实际代码中。