Abstract Factory抽象工厂模式(Java代码实现)——创建型模式

在本人所编写的关于23种设计模式的文章中，前言基本上都是一样的，读者可以从章节2开始阅读，本篇是关于创建型模式中抽象工厂模式（Abstract Factory Pattern）的详解。

文章目录

1.前言

根据Design Patterns - Elements of Reusable Object-Oriented Software（中文译名：设计模式 - 可复用面向对象软件的基础）一书，四位作者把设计模式分为三大类，分别如下：

1.创建型模式
这些设计模式提供了一种在创建对象的同时隐藏创建逻辑的方式，而不是使用 new 运算符直接实例化对象。这使得程序在判断针对某个给定实例需要创建哪些对象时更加灵活。

单例模式（Singleton Pattern）
抽象工厂模式（Abstract Factory Pattern）
工厂方法模式（Factory Method Pattern）
建造者模式（Builder Pattern）
原型模式（Prototype Pattern）

2.结构型模式
这些设计模式关注类和对象的组合。继承的概念被用来组合接口和定义组合对象获得新功能的方式。

适配器模式（Adapter Pattern）
桥接模式（Bridge Pattern）
组合模式（Composite Pattern）
装饰器模式（Decorator Pattern）
外观模式（Facade Pattern）
享元模式（Flyweight Pattern）
代理模式（Proxy Pattern）

3.行为型模式
这些设计模式特别关注对象之间的通信。

责任链模式（Chain of Responsibility Pattern）
命令模式（Command Pattern）
解释器模式（Interpreter Pattern）
迭代器模式（Iterator Pattern）
中介者模式（Mediator Pattern）
备忘录模式（Memento Pattern）
观察者模式（Observer Pattern）
状态模式（State Pattern）
策略模式（Strategy Pattern）
模板模式（Template Pattern）
访问者模式（Visitor Pattern）

本篇是关于创建型模式中抽象工厂模式（Abstract Factory Pattern）的详解。

2.抽象工厂模式（Abstract Factory Pattern）

2.1意图

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

2.2UML类图

抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。
在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。
如下（还是以现在热门的奶茶为例）：
在这里插入图片描述

2.3Java代码具体实现

2.3.1包结构如下

在这里插入图片描述

2.3.2factory包

public abstract class AbstractFactory {
    
    
    public abstract Tea getTea(String tea);
    public abstract SmallMaterial getSmallMaterial(String smallmaterial);
}

/**
 * @Author: YuShiwen
 * @Date: 2022/2/5 12:55 AM
 * @Version: 1.0
 */
public class FactoryProducer {
    
    
    public static AbstractFactory getFactory(String factory){
    
    
        if ("smallMaterial".equalsIgnoreCase(factory)){
    
    
            return new SmallMaterialFactory();
        }else if ("Tea".equalsIgnoreCase(factory)){
    
    
            return new TeaFactory();
        }else {
    
    
            throw new RuntimeException("暂不支持改名称的工厂!");
        }
    }
}

/**
 * @Author: YuShiwen
 * @Date: 2022/2/5 12:48 AM
 * @Version: 1.0
 */
public class SmallMaterialFactory extends AbstractFactory {
    
    
    @Override
    public Tea getTea(String tea) {
    
    
        return null;
    }

    @Override
    public SmallMaterial getSmallMaterial(String smallmaterial) {
    
    
        if ("coconut".equalsIgnoreCase(smallmaterial)) {
    
    
            return new Coconut();
        } else if ("pearl".equalsIgnoreCase(smallmaterial)) {
    
    
            return new Pearl();
        } else if ("sago".equalsIgnoreCase(smallmaterial)) {
    
    
            return new Sago();
        } else {
    
    
            throw new RuntimeException("其他茶品暂不支持！");
        }
    }
}

/**
 * @Author: YuShiwen
 * @Date: 2022/2/3 10:43 PM
 * @Version: 1.0
 */
public class TeaFactory extends AbstractFactory{
    
    
    @Override
    public Tea getTea(String tea) {
    
    
        if ("blackTea".equalsIgnoreCase(tea)) {
    
    
            return new BlackTea();
        } else if ("greenTea".equalsIgnoreCase(tea)) {
    
    
            return new GreenTea();
        } else if ("milkTea".equalsIgnoreCase(tea)) {
    
    
            return new MilkTea();
        } else {
    
    
            throw new RuntimeException("其他茶品暂不支持！");
        }
    }

    @Override
    public SmallMaterial getSmallMaterial(String smallmaterial) {
    
    
        return null;
    }
}

2.3.3smallmaterial包

public interface SmallMaterial {
    
    
    void add();
}

public class Sago implements SmallMaterial {
    
    
    @Override
    public void add() {
    
    
        System.out.println("加入小料西米!");
    }
}

public class Pearl implements SmallMaterial {
    
    
    @Override
    public void add() {
    
    
        System.out.println("加入小料珍珠!");
    }
}

public class Coconut implements SmallMaterial {
    
    
    @Override
    public void add() {
    
    
        System.out.println("加入小料椰果!");
    }
}

2.3.4tea包

public interface Tea {
    
    
    void make();
}

public class MilkTea implements Tea {
    
    
    @Override
    public void make() {
    
    
        System.out.println("make the milk tea!");
    }
}

public class GreenTea implements Tea {
    
    
    @Override
    public void make() {
    
    
        System.out.println("make the green tea!");
    }
}

public class BlackTea implements Tea {
    
    


    @Override
    public void make() {
    
    
        System.out.println("make the black tea!");
    }
}

2.3.5main包

/**
 * @Author: YuShiwen
 * @Date: 2022/2/3 10:58 PM
 * @Version: 1.0
 */
public class CustomerDemo {
    
    
    public static void main(String[] args) {
    
    
        FactoryProducer.getFactory("Tea").getTea("milkTea").make();
        AbstractFactory smallMaterial = FactoryProducer.getFactory("smallMaterial");
        smallMaterial.getSmallMaterial("sago").add();
        smallMaterial.getSmallMaterial("Pearl").add();
        smallMaterial.getSmallMaterial("Coconut").add();
    }
}

2.3.6 运行结果

在这里插入图片描述

2.4优缺点

优点：
当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。

缺点：
产品族扩展非常困难，要增加一个系列的某一产品，既要在抽象的 Creator 里加代码，又要在具体的里面加代码。

建议：
抽象工厂模式是为了让创建工厂和一组产品与使用相分离，并可以随时切换到另一个工厂以及另一组产品；
抽象工厂模式实现的关键点是定义工厂接口和产品接口，但如何实现工厂与产品本身需要留给具体的子类实现，使用者只和抽象工厂与抽象产品打交道。