【设计模式】抽象工厂模式

主页传送门：💁 传送

1.抽象工厂模式定义

       抽象工厂（Abstract Factory Pattern）是一种常用的设计模式，在我们的日常开发中总能见到它的身影。其定义为：

Provider an interface for creating families of related or dependent objects without specifying their concrete classes.

       即：为创建一组相关或相互依赖的对象提供一个接口，而且无需指定它们的具体类。
       抽象工厂通用类图如下：

2.抽象工厂实战案例

2.1.场景说明

       举个生活中常见的例子——组装电脑，我们在组装电脑的时候，通常需要选择一系列的配件，比如CPU、硬盘、内存、主板、电源、机箱等。为讨论使用简单点，只考虑选择CPU和主板的问题。
       事实上，在选择CPU的时候，面临一系列的问题，比如品牌、型号、针脚数目、主频等问题，只有把这些问题都确定下来，才能确定具体的CPU。
       同样，在选择主板的时候，也有一系列问题，比如品牌、芯片组、集成芯片、总线频率等问题，也只有这些都确定了，才能确定具体的主板。
       选择不同的CPU和主板，是每个客户在组装电脑的时候，向装机公司提出的要求，也就是我们每个人自己拟定的装机方案。
       在最终确定这个装机方案之前，还需要整体考虑各个配件之间的兼容性。比如：CPU和主板，如果使用Intel的CPU和AMD的主板是根本无法组装的。因为Intel的CPU针脚数与AMD主板提供的CPU插口不兼容，就是说如果使用Intel的CPU根本就插不到AMD的主板中，所以装机方案是整体性的，里面选择的各个配件之间是有关联的。
       对于装机工程师而言，他只知道组装一台电脑，需要相应的配件，但是具体使用什么样的配件，还得由客户说了算。也就是说装机工程师只是负责组装，而客户负责选择装配所需要的具体的配件。因此，当装机工程师为不同的客户组装电脑时，只需要根据客户的装机方案，去获取相应的配件，然后组装即可。

2.2.关系类图

2.3.代码实现

CPU接口与具体实现

public interface Cpu {
    public void calculate();
}

public class IntelCpu implements Cpu {
    /**
     * CPU的针脚数
     */
    private int pins = 0;
    public  IntelCpu(int pins){
        this.pins = pins;
    }
    @Override
    public void calculate() {
        // TODO Auto-generated method stub
        System.out.println("Intel CPU的针脚数：" + pins);
    }

}

public class AmdCpu implements Cpu {
    /**
     * CPU的针脚数
     */
    private int pins = 0;
    public  AmdCpu(int pins){
        this.pins = pins;
    }
    @Override
    public void calculate() {
        // TODO Auto-generated method stub
        System.out.println("AMD CPU的针脚数：" + pins);
    }
}

主板接口与具体实现

public interface Mainboard {
    public void installCPU();
}

public class IntelMainboard implements Mainboard {
    /**
     * CPU插槽的孔数
     */
    private int cpuHoles = 0;
    /**
     * 构造方法，传入CPU插槽的孔数
     * @param cpuHoles
     */
    public IntelMainboard(int cpuHoles){
        this.cpuHoles = cpuHoles;
    }
    @Override
    public void installCPU() {
        // TODO Auto-generated method stub
        System.out.println("Intel主板的CPU插槽孔数是：" + cpuHoles);
    }

}

public class AmdMainboard implements Mainboard {
    /**
     * CPU插槽的孔数
     */
    private int cpuHoles = 0;
    /**
     * 构造方法，传入CPU插槽的孔数
     * @param cpuHoles
     */
    public AmdMainboard(int cpuHoles){
        this.cpuHoles = cpuHoles;
    }
    @Override
    public void installCPU() {
        // TODO Auto-generated method stub
        System.out.println("AMD主板的CPU插槽孔数是：" + cpuHoles);
    }
}

抽象工厂类和实现类：

public interface AbstractFactory {
    /**
     * 创建CPU对象
     * @return CPU对象
     */
    public Cpu createCpu();
    /**
     * 创建主板对象
     * @return 主板对象
     */
    public Mainboard createMainboard();
}

public class IntelFactory implements AbstractFactory {

    @Override
    public Cpu createCpu() {
        // TODO Auto-generated method stub
        return new IntelCpu(755);
    }

    @Override
    public Mainboard createMainboard() {
        // TODO Auto-generated method stub
        return new IntelMainboard(755);
    }

}

public class AmdFactory implements AbstractFactory {

    @Override
    public Cpu createCpu() {
        // TODO Auto-generated method stub
        return new IntelCpu(938);
    }

    @Override
    public Mainboard createMainboard() {
        // TODO Auto-generated method stub
        return new IntelMainboard(938);
    }

}

装机工程师类

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和主板的具体实现，为了示例简单，这里只准备这两个
        //可是，装机工程师并不知道如何去创建，怎么办呢？
        
        //直接找相应的工厂获取
        this.cpu = af.createCpu();
        this.mainboard = af.createMainboard();
        
        //测试配件是否好用
        this.cpu.calculate();
        this.mainboard.installCPU();
    }
}

客户端场景类

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

3.抽象工厂优缺点

抽象工厂模式的优点包括：

• 提供了一种封装对象创建过程的方式：抽象工厂模式将对象的创建过程封装在了具体的工厂类中，客户端只需要关注工厂接口和产品接口，无需关心具体的实现细节。
• 实现了产品族的切换：通过使用不同的具体工厂类，可以方便地切换整个产品族的产品，从而实现了接口与实现的分离。
• 保持了代码的一致性：抽象工厂模式保持了一致性，即所有由同一工厂创建的产品都相互关联，使得产品之间可以很方便地进行配合使用。

然而，抽象工厂模式也存在一些缺点：

• 抽象工厂模式的最大缺点就是产品族扩展非常困难，我们以通用代码为例，如果要增加一个产品C，也就是说产品等级结构由原来的2个增加到3个。此时，抽象类AbstractFactory要增加一个方法createProductC()，然后具体工厂实现类都要修改，这严重违反了开闭原则，会带来较大的不便。
• 增加了系统的复杂度：抽象工厂模式引入了多个抽象和具体类，增加了系统的复杂度和理解难度。

4.抽象工厂使用场景

抽象工厂模式的使用场景包括但不限于以下情况：

• 一个系统要独立于它的产品的创建、组合和表示时。
• 一个系统要由多个产品系列中的一个来配置时。
• 需要强调一系列相关的产品对象的设计以便进行联合使用时。
• 提供了一个产品类库，而只想显示它们的接口而不是实现时。

     例如，在Web应用中，如果需要实现不同种类的饮品，如浓缩咖啡、卡布奇诺、拿铁等，可以采用抽象工厂模式。这将饮品的种类作为产品族，不同种类的饮品则是产品族中的不同产品。每个饮品可以由一个具体的工厂类来构建，而所有的工厂类都可以基于同一个抽象工厂接口来实现。

     在游戏开发中，抽象工厂模式同样可以起到重要作用。例如，如果一个游戏需要不同种类的武器和防具，可以将武器和防具视为不同的产品族，每个具体的武器或防具则是产品族中的不同产品。此时，可以采用抽象工厂模式来构建不同的工厂类，每个工厂类负责创建不同种类的武器或防具。这样，通过简单的修改工厂类，就可以很容易地扩展游戏的武器和防具系统。

     总的来说，抽象工厂模式适用于需要创建一系列相关或相互依赖对象的情况，而无需指定它们具体的类。

5.抽象工厂总结

     无论是简单工厂模式，工厂方法模式，还是抽象工厂模式，他们都属于工厂模式，在形式和特点上也是极为相似的，他们的最终目的都是为了解耦。在使用时，结合通用代码与实际的业务，尝试结构改造，慢慢体会其中的感受，慢慢总结出属于自己的葵花宝典。

如果喜欢的话，欢迎 🤞关注 👍点赞 💬评论 🤝收藏 🙌一起讨论
你的支持就是我✍️创作的动力！ 💞💞💞