JAVA设计模式之抽象工厂模式

一 概述

1.1 定义

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

• 抽象工厂模式属于创建型模式
• 工厂方法模式每个工厂只能创建一种类型的产品，而抽象工厂模式则能够创建多种类型的产品

1.2 使用场景

如果你的业务中出现了要依据不同的产品家族来生产其旗下的一系列产品的时候，抽象工厂模式就配上用场了。

例如小米公司和苹果公司就是两个不同产品家族，而他们两家都生产笔记本电脑和手机，那么小米的笔记本电脑和苹果的笔记本电脑肯定不一样，手机情况也是如此。这就构成了两个产品家族的系列产品之间比较的关系。

再比如麦当劳和肯德基是两个不同的产品家族，他们都生产汉堡和果汁。

抽象工厂模式是三种工厂模式中最为复杂的一个，其关键在于品牌家族的概念，这里的一个工厂要生产某一个品牌家族里面的系列产品。

1.3 UML 类图

角色说明：

• AbstractProduct（抽象产品类）：定义产品的公共接口
• ConcreteProduct（具体产品类）：定义产品的具体对象，实现抽象产品类中的接口
• AbstractFactory（抽象工厂类）：定义工厂中用来创建不同产品的方法
• ConcreteFactory（具体工厂类）：实现抽象工厂中定义的创建产品的方

二 实现

2.1 创建抽象产品类

定义公共接口：

    // 抽象产品类-- CPU
    public abstract class CPU {
        public abstract void showCPU();
    }
    // 抽象产品类-- 内存
    public abstract class Memory {
        public abstract void showMemory();
    }
    // 抽象产品类-- 硬盘
    public abstract class HD {
        public abstract void showHD();
    }

2.2 创建具体产品类

继承 Product 类：

    // 具体产品类-- Intet CPU
    public class IntelCPU extends CPU {

        @Override
        public void showCPU() {
            System.out.println("Intet CPU");
        }
    }
    
    // 具体产品类-- AMD CPU
    public class AmdCPU extends CPU {

        @Override
        public void showCPU() {
            System.out.println("AMD CPU");
        }
    }

    // 具体产品类-- 三星 内存
    public class SamsungMemory extends Memory {

        @Override
        public void showMemory() {
            System.out.println("三星 内存");
        }
    }
    
    // 具体产品类-- 金士顿 内存
    public class KingstonMemory extends Memory {

        @Override
        public void showMemory() {
            System.out.println("金士顿 内存");
        }
    }

    // 具体产品类-- 希捷 硬盘
    public class SeagateHD extends HD {

        @Override
        public void showHD() {
            System.out.println("希捷 硬盘");
        }
    }

    // 具体产品类-- 西部数据 硬盘
    public class WdHD extends HD {

        @Override
        public void showHD() {
            System.out.println("西部数据 硬盘");
        }
    }

2.3 创建抽象工厂类

定义工厂中用来创建不同产品的方法：

    // 抽象工厂类，电脑工厂类
    public abstract class ComputerFactory {
        public abstract CPU createCPU();

        public abstract Memory createMemory();

        public abstract HD createHD();
    }

2.4 创建具体工厂类

继承 Factory 类：

    // 具体工厂类--联想电脑
    public class LenovoComputerFactory extends ComputerFactory {

        @Override
        public CPU createCPU() {
            return new IntelCPU();
        }

        @Override
        public Memory createMemory() {
            return new SamsungMemory();
        }

        @Override
        public HD createHD() {
            return new SeagateHD();
        }
    }
    
    // 具体工厂类--华硕电脑
    public class AsusComputerFactory extends ComputerFactory {

        @Override
        public CPU createCPU() {
            return new AmdCPU();
        }

        @Override
        public Memory createMemory() {
            return new KingstonMemory();
        }

        @Override
        public HD createHD() {
            return new WdHD();
        }
    }
    
    // 具体工厂类--惠普电脑
    public class HpComputerFactory extends ComputerFactory {

        @Override
        public CPU createCPU() {
            return new IntelCPU();
        }

        @Override
        public Memory createMemory() {
            return new KingstonMemory();
        }

        @Override
        public HD createHD() {
            return new WdHD();
        }
    }

2.5 测试方法

    public void test() {
        System.out.println("--------------------生产联想电脑-----------------------");
        ComputerFactory lenovoComputerFactory = new LenovoComputerFactory();
        lenovoComputerFactory.createCPU().showCPU();
        lenovoComputerFactory.createMemory().showMemory();
        lenovoComputerFactory.createHD().showHD();

        System.out.println("--------------------生产华硕电脑-----------------------");
        ComputerFactory asusComputerFactory = new AsusComputerFactory();
        asusComputerFactory.createCPU().showCPU();
        asusComputerFactory.createMemory().showMemory();
        asusComputerFactory.createHD().showHD();
        
        System.out.println("--------------------生产惠普电脑-----------------------");
        ComputerFactory hpComputerFactory = new HpComputerFactory();
        hpComputerFactory.createCPU().showCPU();
        hpComputerFactory.createMemory().showMemory();
        hpComputerFactory.createHD().showHD();
    }

输出结果为：

--------------------生产联想电脑-----------------------
Intet CPU
三星 内存
希捷 硬盘
--------------------生产华硕电脑-----------------------
AMD CPU
金士顿 内存
西部数据 硬盘
--------------------生产惠普电脑-----------------------
Intet CPU
金士顿 内存
西部数据 硬盘

三 总结

3.1 要点

生产多个产品组合的对象时要用到抽象工厂模式。

理解抽象工厂模式的核心关键在于理解品牌家族的概念，简单工厂与工厂方法创建工厂的着眼点为某类具体的产品，某个工厂与某个产品对应，而抽象工厂某个工厂与产品的家族对应，这个工厂可以生产这个品牌家族的一系列产品。

• 要准确识别出当前场景是在构建哪些产品家族的系列产品对象
• 每个产品家族的产品系列都要在 AbstractFactory 接口里面定义

3.2 优点

代码解耦，创建实例的工作与使用实例的工作分开，使用者不必关心类对象如何创建。

3.3 缺点

如果增加新的产品，则修改抽象工厂和所有的具体工厂，违反了开放封闭原则。

3.4 工厂方法模式与抽象工厂模式比较

• 在工厂方法模式中具体工厂负责生产具体的产品，每一个具体工厂对应一种具体产品，工厂方法具有唯一性
• 抽象工厂模式则可以提供多个产品对象，而不是单一的产品对象