设计模式—抽象工厂模式

文章目录

1. 1. 模式定义
2. 2. 模式结构
3. 3. UML图
4. 4. 代码实现
   1. 4.1. AbstractFactory.java
   2. 4.2. AmdFactory.java
   3. 4.3. IntelFactory.java
   4. 4.4. Mainboard.java
   5. 4.5. IntelMainboard.java
   6. 4.6. AmdMainboard.java
   7. 4.7. ComputerEngineer.java
   8. 4.8. 测试类
5. 5. 模式分析
6. 6. 抽象工厂模式的优点
7. 7. 抽象工厂模式的缺点

前面我们学习了了简单工厂模式和工厂方法模式，今天我们来学习设计模式中最后的一种工厂模式——抽象工厂模式(Abstract Factory Pattern)，它属于类创建型模式。

抽象工厂模式其实是工厂方法模式的一种扩展，应用抽象工厂模式可以创建一系列的产品（产品族），而不是像工厂方法模式中的只能创建一种产品。

模式定义

为创建一组相关或相互依赖的对象提供一个接口，而且无需指定他们的具体类。

模式结构

抽象工厂模式包含如下角色：

AbstractFactory： 抽象工厂
ConcreteFactory： 具体工厂
AbstractProduct： 抽象产品
Product： 具体产品

UML图

代码实现

AbstractFactory.java

public interface AbstractFactory {

    Cpu createCpu();

    Mainboard createMainboard();
}

AmdFactory.java

public class AmdFactory implements AbstractFactory {

    @Override
    public Cpu createCpu() {
        return new AmdCpu();
    }

    @Override
    public Mainboard createMainboard() {
        return new AmdMainboard();
    }
}

IntelFactory.java

public class IntelFactory implements AbstractFactory {

    @Override
    public Cpu createCpu() {
        return new IntelCpu();
    }

    @Override
    public Mainboard createMainboard() {
        return new IntelMainboard();
    }
}

Mainboard.java

public interface Mainboard {

    void installCpu();
}

IntelMainboard.java

public class IntelMainboard implements Mainboard {

    public IntelMainboard() {
        System.out.println("Create IntelMainboard");
    }

    @Override
    public void installCpu() {
        System.out.println("IntelMainboard installCpu");
    }
}

AmdMainboard.java

public class AmdMainboard implements Mainboard {

    public AmdMainboard() {
        System.out.println("Create AmdMainboard");
    }

    @Override
    public void installCpu() {
        System.out.println(" AmdMainboard installCpu");
    }
}

ComputerEngineer.java

public class ComputerEngineer  {

    /**
     * 定义组装机需要的CPU
     */
    private Cpu cpu = null;
    /**
     * 定义组装机需要的主板
     */
    private Mainboard mainboard = null;

    public void makeComputer(AbstractFactory af){
        /**
         * 组装机器的基本步骤
         */
        //1:首先准备好装机所需要的配件
        prepareHardwares(af);
        //2:组装机器
        //3:测试机器
        //4：交付客户
    }
    private void prepareHardwares(AbstractFactory af){
        //这里要去准备CPU和主板的具体实现，为了示例简单，这里只准备这两个
        //可是，装机工程师并不知道如何去创建，怎么办呢？

        //直接找相应的工厂获取
        cpu = af.createCpu();
        mainboard = af.createMainboard();

        //测试配件是否好用
        cpu.calculate();
        mainboard.installCpu();
    }
}

测试类

public class MyClass {
    public static void main(String[]args){
        //创建装机工程师对象
        ComputerEngineer cf = new ComputerEngineer();
        //客户选择并创建需要使用的产品对象
        AbstractFactory af = new IntelFactory();
        //告诉装机工程师自己选择的产品，让装机工程师组装电脑
        cf.makeComputer(af);
    }
}

模式分析

每一个模式都是针对一定问题的解决方案，工厂方法模式针对的是一个产品等级结构，而抽象工厂模式针对的是多个产品等级结构。有多少个产品等级结构，就会在工厂角色中发现多少个工厂方法。每一个产品等级结构中有多少个具体的产品，就有多少个产品族，也就会在工厂等级结构中发现多少个具体工厂。

抽象工厂模式的优点

• 抽象工厂模式隔离了具体类的生成，使得客户并不需要知道什么被创建。由于这种隔离，更换一个具体工厂就变得相对容易。所有的具体工厂都实现了抽象工厂中定义的那些公共接口，因此只需改变具体工厂的实例，就可以在某种程度上改变整个软件系统的行为。另外，应用抽象工厂模式可以实现高内聚低耦合的设计目的，因此抽象工厂模式得到了广泛的应用。

• 当一个产品族中的多个对象被设计成一起工作时，它能够保证客户端始终只使用同一个产品族中的对象。这对一些需要根据当前环境来决定其行为的软件系统来说，是一种非常实用的设计模式。

• 增加新的具体工厂和产品族很方便，无须修改已有系统，符合“开闭原则”。

抽象工厂模式的缺点

• 在添加新的产品对象时，难以扩展抽象工厂来生产新种类的产品，这是因为在抽象工厂角色中规定了所有可能被创建的产品集合，要支持新种类的产品就意味着要对该接口进行扩展，而这将涉及到对抽象工厂角色及其所有子类的修改，显然会带来较大的不便。

• 开闭原则的倾斜性（增加新的工厂和产品族容易，增加新的产品等级结构麻烦）。

到现在为止，设计模式中的所有工厂类的模式就都已经学习完了。

代码已经放到GitHub上了https://github.com/HJXANDHMR/DesignPattern。

参考
http://design-patterns.readthedocs.io/zh_CN/latest/creational_patterns/abstract_factory.html
http://www.cnblogs.com/ytaozhao/p/3392149.html

欢迎大家关注我的微信公众号，我会不定期的分享些Android开发的技巧