抽象工厂模式解析

一.概述

1.抽象工厂模式是对简单工厂模式的一个变种

2.简单工厂模式是在fatory类中，通过switch case去判断不同的enum类型，去创建不同的实例，在生产的产品越来越多的时候，工厂类中的判断会越来越多，代码维度也会越来越多

3.抽象工厂模式，在简单工厂模式基础上将工厂分类抽象化，并且利用了反射的机制，在enum类中将类保存，在工厂实现时通过反射即可生成对应的类，减少了判断逻辑，只需要在对应的工厂实现类中将enum类别传入即可

4.抽象工厂符合高内聚低耦合，客户端只需要关注使用哪一个工厂和对应要生产那个种类的产品即可得到想要的产品并使用该产品。

二.使用

本文中的例子是参考的设计模式之禅里的例子，举了生产人的工厂，不同肤色不同性别的生产。

1.Human创建

(1).首先创建人的接口类，定义人的属性

public interface Human {

    //大笑
    void laugh();
    //哭
    void cry();
    //谈话
    void talk();
    //性别，创造人时的差异化：男、女
    void sex();
}

(2).定义好Human接口后，创建三个抽象父类，用于聚合方法，将共性方法在抽象父类中实现，不同方法例如性别在子类中实现。

黄种人的抽象父类如下，白种人和黑种人与其相同

public abstract class AbstractYellowHuman implements Human {
    protected final String TAG = getClass().getSimpleName();

    @Override
    public void laugh() {
        System.out.printf(TAG + "黄种人 laugh！");
    }

    @Override
    public void cry() {
        System.out.printf(TAG + "黄种人 cry！");
    }

    @Override
    public void talk() {
        System.out.printf(TAG + "黄种人 talk！");
    }

}

黄种人的男女子类如下（黑白种人与黄相同）：

public class YellowMaleHuman extends AbstractYellowHuman {


    @Override
    public void sex() {
        System.out.printf(TAG +  "该黄种人是男性！");
    }
}

public class YellowFemaleHuman extends AbstractYellowHuman {


    @Override
    public void sex() {
        System.out.printf(TAG + "该黄种人是女性！");
    }
}

很好的展示了多态，黄种人除了性别差异，其他是一样的。

2.工厂创建

(1)创建工厂接口

/**
 * 工厂总的接口类
 * 定义要生产的产品的方法
 */
public interface HumanFactory {
    Human createYellowHuman();
    Human createWhiteHuman();
    Human createBlackHuman();
}

(2)创建抽象工厂父类，将创建人的方法统一实现

/**
 * 在实现子类和接口HumanFactory之间增加一个抽象父类，在此处定义反射创建所有人类的方法
 * 符合高内聚低耦合的原则，所有子类都可以调用此反射方法，在子类根据实际种类去反射创建对应的人类，达到了多态的目标
 */
public abstract class AbstractHumanFactory implements HumanFactory {
    public Human createHuman(HumanEnum humanEnum) {
        Human human = null;
        try {
            if (!"".equals(humanEnum.getValue())) {
                human = (Human) Class.forName(humanEnum.getValue()).newInstance();
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        }
        return human;
    }
}

HumanEnum枚举如下，配置类所有人的种类对应的反射类的包名类名：

/**
 * 生产人类的所有类别
 * 此处key 类别 value对应class包名类名
 */
public enum HumanEnum {
    YellowMaleHuman("com.garycong.algorithms_and_other_demos.designmode.abstract_factory_pattern.human.YellowMaleHuman"),
    YellowFemaleHuman("com.garycong.algorithms_and_other_demos.designmode.abstract_factory_pattern.human.YellowFemaleHuman"),
    WhiteMaleHuman("com.garycong.algorithms_and_other_demos.designmode.abstract_factory_pattern.human.WhiteMaleHuman"),
    WhiteFemaleHuman("com.garycong.algorithms_and_other_demos.designmode.abstract_factory_pattern.human.WhiteFemaleHuman"),
    BlackMaleHuman("com.garycong.algorithms_and_other_demos.designmode.abstract_factory_pattern.human.BlackMaleHuman"),
    BlackFemaleHuman("com.garycong.algorithms_and_other_demos.designmode.abstract_factory_pattern.human.BlackFemaleHuman"),;

    private String value;

    private HumanEnum(String value) {
        this.value = value;
    }

    //返回枚举value值
    public String getValue() {
        return value;
    }
}

在实现子类和接口HumanFactory之间增加一个抽象父类，在此处定义反射创建所有人类的方法，符合高内聚低耦合的原则，所有子类都可以调用此反射方法，在子类根据实际种类去反射创建对应的人类，达到了多态的目标。

(3)看一下工厂子类，按人种差异化区分，男性和女性工厂，继承AbstractHumanFactory，创建对应性别的不同人种，代码如下：

public class MaleHumanFactory extends AbstractHumanFactory {

    @Override
    public Human createYellowHuman() {
        return super.createHuman(HumanEnum.YellowMaleHuman);
    }

    @Override
    public Human createWhiteHuman() {
        return super.createHuman(HumanEnum.WhiteMaleHuman);

    }

    @Override
    public Human createBlackHuman() {
        return super.createHuman(HumanEnum.BlackMaleHuman);

    }
}

public class FemaleHumanFactory extends AbstractHumanFactory {

    @Override
    public Human createYellowHuman() {
        return super.createHuman(HumanEnum.YellowFemaleHuman);
    }

    @Override
    public Human createWhiteHuman() {
        return super.createHuman(HumanEnum.WhiteFemaleHuman);

    }

    @Override
    public Human createBlackHuman() {
        return super.createHuman(HumanEnum.BlackFemaleHuman);

    }
}

3.调用

使用者调用工厂生产人类方法后，通过反射创建类，并返回给调用者。

看下面调用代码：

/**
 * 生产商
 * 调配工厂生产不同产品
 */
public class HumanProducer {
    public static void main(String[] args) {
      	//多态
        //男人生产工厂
        HumanFactory maleHumanFactory = new MaleHumanFactory();
        //女人生产工厂
        HumanFactory femaleHumanFactory = new FemaleHumanFactory();

        //男人工厂生产不同人种
        Human yellowMaleHuman = maleHumanFactory.createYellowHuman();
        Human whiteMaleHuman = maleHumanFactory.createWhiteHuman();
        Human blackMaleHuman = maleHumanFactory.createBlackHuman();

        //生产出来的黄种男人的行为和性别
        yellowMaleHuman.cry();
        yellowMaleHuman.laugh();
        yellowMaleHuman.talk();
        yellowMaleHuman.sex();

        //女人工厂生产不同人种
        Human yellowFemaleHuman = femaleHumanFactory.createYellowHuman();
        Human whiteFemaleHuman = femaleHumanFactory.createWhiteHuman();
        Human blackFemaleHuman = femaleHumanFactory.createBlackHuman();


        //生产出来的黄种女人的行为和性别
        yellowFemaleHuman.cry();
        yellowFemaleHuman.laugh();
        yellowFemaleHuman.talk();
        yellowFemaleHuman.sex();
    }
}

打印出的log如下：

  YellowMaleHuman黄种人 cry！

  YellowMaleHuman黄种人 laugh！

  YellowMaleHuman黄种人 talk！

  YellowMaleHuman该黄种人是男性！

  YellowFemaleHuman黄种人 cry！

  YellowFemaleHuman黄种人 laugh！

  YellowFemaleHuman黄种人 talk！

  YellowFemaleHuman该黄种人是女性！

总结

可以看出使用了抽象工厂后，调用者无需关心种类，只需要实现对应的工厂子类调用方法即可，充分展现了高内聚低耦合，而且在添加种类时只需要添加枚举、新的字类工厂即可，将简单工厂模式中的switch判断通过反射解决了简单工厂模式每次添加种类都要添加case并实例化的烦恼。

而且抽象工厂模式可以配合策略模式使用，将复杂的场景按策略去处理，是代码逻辑更清晰，后面策略模式会举例如何组合使用。