六 抽象工厂模式【Abstract Factory Pattern】 来自CBF4LIFE 的设计模式0

好了，我们继续上一节课，上一节讲到女娲造人，人是造出来了，世界时热闹了，可是低头一看，都
是清一色的类型，缺少关爱、仇恨、喜怒哀乐等情绪，人类的生命太平淡了，女娲一想，猛然一拍脑袋，
Shit！忘记给人类定义性别了，那怎么办？抹掉重来，然后就把人类重新洗牌，准备重新开始制造人类。
由于先前的工作已经花费了很大的精力做为铺垫，也不想从头开始了，那先说人类（Product 产品类）
怎么改吧，好，有了，给每个人类都加一个性别，然后再重新制造，这个问题解决了，那八卦炉怎么办？
只有一个呀，要么生产出全都是男性，要不都是女性，那不行呀，有了，把已经有了一条生产线——八卦
炉（工厂模式中的 Concrete Factory）拆开，于是女娲就使用了“八卦拷贝术”，把原先的八卦炉一个变两
个，并且略加修改，就成了女性八卦炉（只生产女性，一个具体工厂的实现类）和男性八卦炉（只生产男
性，又一个具体工厂的实现类），这个过程的类图如下：
先看人类（也就是产品）的类图： 这个图有毒.后期再画个清晰的.
 

这个类图也比较简单，Java 的典型类图，一个接口，几个抽象类，然后是几个实现类，没啥多说的，
其中三个抽象类在抽象工厂模式中是叫做产品等级，六个实现类是叫做产品族，这个也比较好理解，实现
类嘛是真实的产品，一个叫产品，多了就叫产品族，然后再看工厂类：

其中抽象工厂只实现了一个 createHuman 的方法，目的是简化实现类的代码工作量，这个在讲代码的
时候会说。这里还使用了 Jdk 1.5 的一个新特性 Enum 类型，其实这个完全可以类的静态变量来实现，但我
想既然是学习就应该学有所获得，即使你对这个模式非常了解，也可能没用过 Enum 类型，也算是一个不同
的知识点吧，我希望给大家讲解，每次都有新的技术点提出来，每个人都会有一点的收获就足够了，然后
在具体的项目中使用时，知道有这个技术点，然后上 baidu 狗狗一下就能解决问题。话题扯远了，我们继
续类图，完整的类图如下，这个看不大清楚，其实就是上面那两个类图加起来，大家可以看源码中的那个
类图文件：
 我们来看程序实现：

接口实现:

package AbstractFactory;

/**
 * @author lhb
 * @类名 IHuman
 * @描述 定义一个人类的统称，问题出来了，刚刚定义的时候忘记定义性别了 这个重要的问题非修改不可，否则这个世界上太多太多的东西不存在了
 * @时间 2022/6/17 10:51
 * @版本
 **/
public interface IHuman {
    default  void laugh(){

    };
    void cry();
    void talk();
    void sex();
}

三个抽象类都实现完毕了，然后就是些实现类了。其实，你说抽象类放这里有什么意义吗？就是不允
许你 new 出来一个抽象的对象呗，使用非抽象类完全就可以代替，呵呵，杀猪杀尾巴，各有各的杀法，不
过既然进了 Java 这个门就要遵守 Java 这个规矩，我们看实现类：

抽象类实现  黑人抽象类

package AbstractFactory;

/**
 * @author lhb
 * @类名 AbstracctBlackHuman
 * @描述
 * @时间 2022/6/17 10:55
 * @版本
 **/
public abstract class AbstracctBlackHuman implements IHuman{
    @Override
    public void laugh() {
        System.out.println("黑人类会笑");
    }

    @Override
    public void cry() {
        System.out.println("黑人类会哭");
    }

    @Override
    public void talk() {
        System.out.println("黑人类可以说话.一般情况是听不懂的.");
    }

}

白人抽象类

package AbstractFactory;

/**
 * @author lhb
 * @类名 AbstractWhiteHuman
 * @描述
 * @时间 2022/6/17 11:17
 * @版本
 **/
public abstract  class AbstractWhiteHuman implements IHuman{
    @Override
    public void laugh() {
        System.out.println("白人类会笑");
    }

    @Override
    public void cry() {
        System.out.println("白人类会哭");
    }

    @Override
    public void talk() {
        System.out.println("白人类可以说话.一般情况是听不懂的.");
    }

}

抽象工厂模式下的产品等级和产品族都已经完成，也就是人类以及产生出的人类是什么样子的都已经
定义好了，下一步就等着工厂开工创建了，那我们来看工厂类。
在看工厂类之前我们先看那个枚举类型，这个是很有意思的：

package AbstractFactory;

/**
 * @author lhb
 * @类名 EnumHuman
 * @描述 java enum类型尽量简单使用，尽量不要使用多态、继承等方法   * 毕竟用Class完全可以代替enum
 * @时间 2022/6/17 11:36
 * @版本
 **/
public enum EnumHuman {
    WhiteFemaleHuman("AbstractFactory.WhiteFemaleHume"),
    BlackFemaleHuman("AbstractFactory.BlackFemaleHuman"),
    WhiteMaleHuman("AbstractFactory.WhiteMaleHuman"),
    BlackMaleHuman("AbstractFactory.BlackMaleHuman");

    private String value = "";
    private EnumHuman(String value){
       this.value = value;
    }
    public String getValue(){
        return  this.value;
    }

}

我之所以引入 Enum 这个类型，是想让大家在看这本书的时候能够随时随地的学到点什么，你如果看不
懂设计模式，你可以从我的程序中学到一些新的技术点，不用像我以前报着砖头似的书在那里啃，看一遍
不懂，再看第二遍，然后翻了英文原本才知道，哦~，原来是这样滴，只能说有些翻译家实在不懂技术。我
在讲解技术的时候，尽量少用专业术语，尽量使用大部分人类都能理解的语言。
Enum 以前我也很少用，近在一个项目中偶然使用上了，然后才发觉它的好处，Enum 类型作为一个参
数传递到一个方法中时，在 Junit 进行单元测试的时候，不用判断输入参数是否为空、长度为 0 的边界异
常条件，如果方法传入的参数不是 Enum 类型的话，根本就传递不进来，你说定义一个类，定义一堆的静态
变量，这也可以呀，这个不和你抬杠，上面的代码我解释一下，构造函数没啥好说的，然后是 getValue()
方法，就是获得枚举类型中一个元素的值，枚举类型中的元素也是有名称和值的，这个和 HashMap 有点类
似。
然后，我们看我们的工厂类，先看接口：

package AbstractFactory;

/**
 * @author lhb
 * @类名 IHumanFactory
 * @描述
 * @时间 2022/6/20 11:25
 * @版本
 **/
public interface IHumanFactory {
    //制造黄色人类
    IHuman createYellowHuman();
    IHuman createWhiteHuman();
    IHuman createBlackHuman();
}

然后看抽象类：

package AbstractFactory;

/**
 * @author lhb
 * @类名 AbstractHumanFactory
 * @描述
 * @时间 2022/6/20 11:26
 * @版本
 **/
public abstract class AbstractHumanFactory implements IHumanFactory{
    protected IHuman createHuman(EnumHuman enumHuman){
        IHuman human =null;
        //如果传递进来不是一个Enum中具体的一个Element的话，则不处理
        if(!enumHuman.getValue().equals("")){
            try{
                human = (IHuman) Class.forName(enumHuman.getValue()).newInstance();
            }catch (Exception e){
                e.printStackTrace();
            }
        }
        return human;
    }

}

看到没，这就是引入 enum 的好处，createHuman(HumanEnum humanEnum)这个方法定义了输入参数必须
是 HumanEnum 类型，然后直接使用 humanEnum.getValue()方法就能获得具体传递进来的值，这个不多说了，
大家自己看程序领会，没多大难度，这个抽象类的目的就是减少下边实现类的代码量，我们看实现类：
男性工厂，只创建男性：

package AbstractFactory;

/**
 * @author lhb
 * @类名 MaleHumanFactory
 * @描述
 * @时间 2022/6/20 11:42
 * @版本
 **/
public class MaleHumanFactory extends AbstractHumanFactory{
    @Override
    public IHuman createYellowHuman() {
        return null;
    }

    @Override
    public IHuman createWhiteHuman() {
        return super.createHuman(EnumHuman.WhiteMaleHuman);
    }

    @Override
    public IHuman createBlackHuman() {
        return super.createHuman(EnumHuman.BlackMaleHuman);
    }
}

女性工厂，只创建女性：

package AbstractFactory;

/**
 * @author lhb
 * @类名 FemaleHumanFactory
 * @描述
 * @时间 2022/6/20 11:44
 * @版本
 **/
public class FemaleHumanFactory extends AbstractHumanFactory{
    @Override
    public IHuman createYellowHuman() {
        return null;
    }

    @Override
    public IHuman createWhiteHuman() {
        return super.createHuman(EnumHuman.WhiteFemaleHuman);
    }

    @Override
    public IHuman createBlackHuman() {
        return super.createHuman(EnumHuman.BlackFemaleHuman);
    }
}

产品定义好了，工厂也定义好了，万事俱备只欠东风，那咱就开始造吧，哦，不对，女娲开始造人了：

package AbstractFactory;

/**
 * @author lhb
 * @类名 NvWa
 * @描述
 * @时间 2022/6/20 14:34
 * @版本
 **/
public class NvWa {
    public static void main(String[] args) {
        IHumanFactory maleHumanFactory = new MaleHumanFactory();
        IHumanFactory femaleHumanFactory = new FemaleHumanFactory();

        IHuman maleWhiteHuman = maleHumanFactory.createWhiteHuman();
        IHuman femaleWhiteHuman = femaleHumanFactory.createWhiteHuman();
        maleWhiteHuman.cry();
        maleWhiteHuman.laugh();;
        femaleWhiteHuman.talk();
    }
}

两个八卦炉，一个造女的，一个造男的，开足马力，一直造到这个世界到现在这个模式为止。
抽象工厂模式讲完了，那我们再思考一些问题：工厂模式有哪些优缺点？先说优点，我这人一般先看
人优点，非常重要的有点就是，工厂模式符合 OCP 原则，也就是开闭原则，怎么说呢，比如就性别的问题，
这个世界上还存在双性人，是男也是女的人，那这个就是要在我们的产品族中增加一类产品，同时再增加
一个工厂就可以解决这个问题，不需要我再来实现了吧，很简单的大家自己画下类图，然后实现下。
那还有没有其他好处呢？抽象工厂模式，还有一个非常大的有点，高内聚，低耦合，在一个较大的项
目组，产品是由一批人定义开发的，但是提供其他成员访问的时候，只有工厂方法和产品的接口，也就是
说只需要提供 Product Interface 和 Concrete Factory 就可以产生自己需要的对象和方法，Java 的高内聚
低耦合的特性表现的一览无遗，哈哈。