抽象工厂模式

抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

相当于把所有工厂又封装了一遍。

示例演示：

1. 模仿工厂模式，我们创建两个接口，一个生物，一个性别，分别有两个实现类

   package test.abstractFactory;
   /**
    * 所有生物的标识
    */
   public interface Organism {
       //所有生物共有的一个功能，有自己的沟通方式
       void say();
   }

   package test.abstractFactory;
   
   public class People implements Organism{
   
       @Override
       public void say() {
           System.out.println("people say");
       }
   }

   package test.abstractFactory;
   
   public class Animal implements Organism{
   
       @Override
       public void say() {
           System.out.println("animal say");
       }
   }

   package test.abstractFactory;
   /**
    * 所有生物都有性别
    */
   public interface Sex {
   
       void sex();
   }

   package test.abstractFactory;
   
   public class Male implements Sex {
       @Override
       public void sex() {
           System.out.println("male");
       }
   }

   package test.abstractFactory;
   
   public class Female implements Sex {
       @Override
       public void sex() {
           System.out.println("female");
       }
   }

2. 创建一个超级工厂

   package test.abstractFactory;
   
   public abstract class AbstractFactory {
   
       public abstract Organism getOrganism(String type);
   
       public abstract Sex getSex(String type);
   
   }

3. 通过继承超级工厂来分别来实现各自的工厂

   package test.abstractFactory;
   
   import org.apache.commons.lang3.StringUtils;
   
   public class OrganismFactory extends AbstractFactory{
   
       @Override
       public Organism getOrganism(String type) {
           if (StringUtils.isBlank(type)) {
               return null;
           }
           if (type.equalsIgnoreCase("people")) {
               return new People();
           } else if (type.equalsIgnoreCase("animal")) {
               return new Animal();
           }
           return null;
       }
   
       @Override
       public Sex getSex(String type) {
           return null;
       }
   }

   package test.abstractFactory;
   
   import org.apache.commons.lang3.StringUtils;
   
   public class SexFactory extends AbstractFactory{
   
       @Override
       public Organism getOrganism(String type) {
           return null;
       }
   
       @Override
       public Sex getSex(String type) {
           if (StringUtils.isBlank(type)) {
               return null;
           }
           if (type.equalsIgnoreCase("male")) {
               return new Male();
           } else if (type.equalsIgnoreCase("female")) {
               return new Female();
           }
           return null;
       }
   }

4. 创建一个工厂创造器

   package test.abstractFactory;
   
   import org.apache.commons.lang3.StringUtils;
   
   public class FactoryProducer {
   
       public static AbstractFactory getFactory(String type) {
           if (StringUtils.isBlank(type)) {
               return null;
           }
           if (type.equalsIgnoreCase("organism")) {
               return new OrganismFactory();
           } else if (type.equalsIgnoreCase("sex")) {
               return new SexFactory();
           }
           return null;
       }
   }

5. 完成上述步骤，我们就可以开始演示了

   package test.abstractFactory;
   
   public class AbstractFactoryDemo {
       public static void main(String[] args) {
           AbstractFactory organismFactory = FactoryProducer.getFactory("organism");
           Organism people = organismFactory.getOrganism("people");
           people.say();
   
           Organism animal = organismFactory.getOrganism("animal");
           animal.say();
   
           AbstractFactory sexFactory = FactoryProducer.getFactory("sex");
   
           Sex male = sexFactory.getSex("male");
           male.sex();
   
           Sex female = sexFactory.getSex("female");
           female.sex();
   
       }
   }

   运行结果：

   people say
   animal say
   male
   female

说明：

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

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