定义了一个接口用于创建相关或有依赖关系的对象簇，而无需指明具体的类，抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合。

    • 优点：
      • 代码解耦
      • 可以实现多个产品族(相关联产品组成的家族)，相对工厂方法模式的单个产品，可以满足更多的生产需求
      • 很好的满足OCP开放封闭原则
    • 缺点：
      • 扩展产品族相当麻烦，而且扩展产品族会违反OCP，因为要修改所有的工厂
      • 由于抽象工厂模式是工厂方法模式的扩展，总体的来说很笨重
    1. /**
    2.  * 球类
    3.  */
    4. public interface Ball {
    5.     void play();
    6. }
    1. /**
    2.  * 篮球
    3.  */
    4. public class BasketBall implements Ball {
    5.     @Override
    6.     public void play() {
    7.         System.out.println("打篮球");
    8.     }
    9. }
    1. /**
    2.  * 足球
    3.  */
    4. public class FootBall implements Ball {
    5.     @Override
    6.     public void play() {
    7.         System.out.println("踢足球");
    8.     }
    9. }
    1. /**
    2.  * 球衣类
    3.  */
    4. public interface Shirt {
    5.     void show();
    6. }
    1. /**
    2.  * 长袖球衣
    3.  */
    4. public class LongShirt implements Shirt {
    5.     @Override
    6.     public void show() {
    7.         System.out.println("穿着长袖球衣");
    8.     }
    9. }
    1. /**
    2.  * 短袖球衣
    3.  */
    4. public class ShortShirt implements Shirt {
    5.     @Override
    6.     public void show() {
    7.         System.out.println("穿着短袖球衣");
    8.     }
    9. }
    1. /**
    2.  * 体育用品工厂类
    3.  */
    4. public interface SportFactory {
    5.     // 获取球类
    6.     Ball createBall();
    7.     // 获取球衣
    8.     Shirt createShirt();
    9. }
    1. /**
    2.  * 耐克体育工厂
    3.  */
    4. public class NikeSportFactory implements SportFactory {
    5.     @Override
    6.     public Ball createBall() {
    7.         return new BasketBall();
    8.     }
    9.     @Override
    10.     public Shirt createShirt() {
    11.         return new LongShirt();
    12.     }
    13. }
    1. /**
    2.  * 李宁体育工厂
    3.  */
    4. public class LiNingSportFactory implements SportFactory {
    5.     @Override
    6.     public Ball createBall() {
    7.         return new FootBall();
    8.     }
    9.     @Override
    10.     public Shirt createShirt() {
    11.         return new ShortShirt();
    12.     }
    13. }
    1. public class AbstractFactoryTest {
    2.     public static void main(String[] args) {
    3.         // 耐克体育工厂
    4.         SportFactory nikeSportFactory = new NikeSportFactory();
    5.         System.out.println("耐克体育工厂:");
    6.         Ball nikeBall = nikeSportFactory.createBall();
    7.         nikeBall.play();
    8.         Shirt nikeShirt = nikeSportFactory.createShirt();
    9.         nikeShirt.show();
    11.         // 李宁体育工厂
    12.         SportFactory liNingSportFactory = new LiNingSportFactory();
    13.         System.out.println("李宁体育工厂:");
    14.         Ball liNingBall = liNingSportFactory.createBall();
    15.         liNingBall.play();
    16.         Shirt liNingShirt = liNingSportFactory.createShirt();
    17.         liNingShirt.show();
    18.     }
    19. }
    20. ----输出----
    21. 耐克体育工厂:
    22. 打篮球
    23. 穿着长袖球衣
    25. 李宁体育工厂:
    26. 踢足球
    27. 穿着短袖球衣

    【三种工厂模式的总结】

    • 简单工厂模式：最大的特点就是工厂内有具体的逻辑去判断生成什么产品，将类的实例化交给了工厂，这样当我们需要什么产品只需要修改客户端的调用而不需要去修改工厂，对于客户端来说降低了与具体产品的依赖
    • 工厂方法模式：是简单工厂的扩展，工厂方法模式把原先简单工厂中的实现那个类的逻辑判断交给了客户端，如果像添加功能只需要修改客户和添加具体的功能，不用去修改之前的类。
    • 抽象工厂模式：进一步扩展了工厂方法模式，它把原先的工厂方法模式中只能有一个抽象产品不能添加产品族的缺点克服了，抽象工厂模式不仅仅遵循了OCP原则(对扩展开放，对修改关闭)，而且可以添加更多产品(抽象产品),具体工厂也不仅仅可以生成单一产品，而是生成一组产品，抽象工厂也是声明一组产品，对应扩展更加灵活，但是要是扩展族系就会很笨重。