抽象工厂设计模式

1.写在前面

2021年，首先祝福大家新年好，今天笔者带大家来了解一下抽象工厂模式，废话不多说，直接上代码。

2.抽象工厂模式

好了，我们继续上一节课，上一节讲到女娲造人，人是造出来了，世界是热闹了，可是低头一看，都是清一色的类型，缺少关爱、仇恨、喜怒哀乐等情绪，人类的生命太平淡了，女娲一想，猛然一拍脑袋，shit！忘记给人类定义性别了，那怎么办？抹掉重来，然后就把人类重新洗牌，准备重新开始制造人类。

由于先前的工作已经花费了很大的精力作为铺垫，也不想从头开始了，那先说人类(Product产品类)怎么改吧，好，有了，给每个人类都加一个性别，然后再重新制造，这个问题解决了，那八卦炉怎么办？只有一个呀，要么生产出全都是男性，要不都是女性，那不行呀，有了，把已经有了一条生产线-----八卦炉（生产模式中的Concrete Factory）拆开，于是女娲就使用了“八卦拷贝术”，把原先的八卦炉一个变两个，并且略加修改，就成了女性八卦炉（只生产女性，一个具体工厂的实现类）和男性八卦炉（只生产男性，又一个具体工厂的实现类），这个过程的类图如下：

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

package com.ys;

/*
 * 定义一个人类的统称，问题出来了，刚刚定义的时候忘记定义性别了
 * 这个重要的问题非修改不可，否则这个世界上太多太多的东西不存在了
 * */
public interface Human {
    //首先定义什么是人类

    //人是愉快的，会笑的，本来是想用smile表示，想了一下laugh更合适，好长时间没有大笑了；
    public void laugh();

    //人类还会哭，代表痛苦
    public void cry();

    //人类会说话
    public void talk();

    //定义性别
    public void sex();

}

人类的接口定义好，然后根据接口创建三个抽象类，也就是三个产品等级，实现laugh()、cry()、talk()三个方法，以AbstractYellowHuman 为例：

package com.ys;

/*
 * 为什么要修改成抽象类呢？要定义性别呀
 * */
public abstract class AbstractYellowHuman implements Human {
    @Override
    public void laugh() {
        System.out.println("黄色人类会哭");
    }

    @Override
    public void cry() {
        System.out.println("黄色人类会大笑，幸福呀！ ");
    }

    @Override
    public void talk() {
        System.out.println("黄色人类会说话，一般说的都是双字节");
    }
}

其他的两个抽象类AbstractWhiteHuman 和 AbstractgBlackHuman 与此类似的事项方法

package com.ys;

/*
 * 为什么要修改成抽象类呢？要定义性别呀
 * */
public abstract class AbstractWhiteHuman implements Human {
    @Override
    public void laugh() {
        System.out.println("白色人类会哭");
    }

    @Override
    public void cry() {
        System.out.println("白色人类会大笑，侵略的笑声");
    }

    @Override
    public void talk() {
        System.out.println("白色人类会说话，一般都是但是单字节！ ");
    }
}

黑色人种的抽象类：

package com.ys;

/*
 * 为什么要修改成抽象类呢？要定义性别呀
 * */
public abstract class AbstractBlackHuman implements Human {
    @Override
    public void laugh() {
        System.out.println("黑人会哭");
    }

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

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

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

女性黄种人的实现类：

package com.ys;

public class YellowFemaleHuman extends AbstractYellowHuman {
    @Override
    public void sex() {
        System.out.println("该黄种人的性别为女....");
    }
}

男性黄种人的实现类

package com.ys;

public class YellowMaleHuman extends AbstractYellowHuman {
    @Override
    public void sex() {
        System.out.println("该黄种人的性别为男....");
    }
}

女性白种人的实现类

package com.ys;

public class WhiteFemaleHuman extends AbstractWhiteHuman {
    @Override
    public void sex() {
        System.out.println("该白种人的性别为女...");
    }
}

男性白种人的实现类

package com.ys;

public class WhiteMaleHuman extends AbstractWhiteHuman {
    @Override
    public void sex() {
        System.out.println("该白种人的性别为男...");
    }
}

女性黑种人的实现类

package com.ys;

public class BlackFemaleHuman extends AbstractBlackHuman {
    @Override
    public void sex() {
        System.out.println("该黑种人的性别为女...");
    }
}

男性黑种人的实现类

package com.ys;

public class BlackMaleHuman extends AbstractBlackHuman {
    @Override
    public void sex() {
        System.out.println("该黑种人的性别为男...");
    }
}

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

package com.ys;

public enum HumanEnum {

    //把世界上多有人的类型都定义出来
    YellowMaleHuman("com.ys.YellowMaleHuman"),
    YellowFemaleHuman("com.ys.YellowFemaleHuman"),
    WhiteMaleHuman("com.ys.WhiteMaleHuman"),
    WhiteFemaleHuman("com.ys.WhiteFemaleHuman"),
    BlackMaleHuman("com.ys.BlackMaleHuman"),
    BlackFemaleHuman("com.ys.BlackFemaleHuman");

    private String value = "";

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

    public String getValue() {
        return value;
    }
}

我之所以引入 Enum 这个类型，是想让大家在看这本博客的时候能够随时随地的学到点什么，你如果看不懂设计模式，你可以从我的程序中学到一些新的技术点，不用像我以前报着砖头似的书在那里啃，看一遍不懂，再看第二遍，然后翻了英文原本才知道，哦~，原来是这样滴，只能说有些翻译家实在不懂技术。我在讲解技术的时候，尽量少用专业术语，尽量使用大部分人类都能理解的语言。

Enum 以前我也很少用，最近在一个项目中偶然使用上了，然后才发觉它的好处，Enum 类型作为一个参数传递到一个方法中时，在 Junit 进行单元测试的时候，不用判断输入参数是否为空、长度为 0 的边界异常条件，如果方法传入的参数不是 Enum 类型的话，根本就传递不进来，你说定义一个类，定义一堆的静态变量，这也可以呀，这个不和你抬杠，上面的代码我解释一下，构造函数没啥好说的，然后是 getValue()方法，就是获得枚举类型中一个元素的值，枚举类型中的元素也是有名称和值的，这个和 HashMap 有点类似。

然后，我们看我们的工厂类，先看接口：

package com.ys;

public interface HumanFactory {
    //制造黄色人类
    public Human createYellowHuman();

    //制造一个白色人类
    public Human createWhiteHuman();

    //制造一个黑色人类
    public Human createBlackHuman();
}

然后看抽象类：

package com.ys;

public abstract class AbstractHumanFactory implements HumanFactory {

    /*
     * 给定一个性别人类，创建一个人类出来 专业术语是产生产品等级
     */
    protected Human createHuman(HumanEnum humanEnum) {
        Human human = null;
        //如果传递进来不是一个Enum中具体的一个Element的话，则不处理
        if (!humanEnum.getValue().equals("")) {
            try {
            //直接产生一个实例
                human = (Human) Class.forName(humanEnum.getValue()).newInstance();
            } catch (Exception e) {
                //因为使用了enum，这个种异常情况不会产生了，除非你的enum有问题；
                e.printStackTrace();
            }
        }
        return human;
    }
}

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

package com.ys;

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);
    }
}

女性工厂，只创建女性：

package com.ys;

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);
    }
}

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

package com.ys;

public class NvWa {

    public static void main(String[] args) {
        //第一条生产线，男性生产线
        HumanFactory maleHumanFactory = new MaleHumanFactory();
        
        //第二条生产线，女性生产线
        HumanFactory femaleHumanFactory = new FeMaleHumanFactory();
        
        //生产线建立完毕，开始生产人了:
        Human maleYellowHuman = maleHumanFactory.createYellowHuman();
        Human femaleYellowHuman = femaleHumanFactory.createYellowHuman();
        
        maleYellowHuman.cry();
        maleYellowHuman.laugh();
        femaleYellowHuman.sex();
    }
}

两个八卦炉，一个造女的，一个造男的，开足马力，一直造到这个世界到现在这个模式为止。抽象工厂模式讲完了，那我们再思考一些问题：工厂模式有哪些优缺点？先说优点，我这人一般先看人优点，非常重要的有点就是，工厂模式符合 OCP 原则，也就是开闭原则，怎么说呢，比如就性别的问题，这个世界上还存在双性人，是男也是女的人，那这个就是要在我们的产品族中增加一类产品，同时再增加一个工厂就可以解决这个问题，不需要我再来实现了吧，很简单的大家自己画下类图，然后实现下。

那还有没有其他好处呢？抽象工厂模式，还有一个非常大的有点，高内聚，低耦合，在一个较大的项目组，产品是由一批人定义开发的，但是提供其他成员访问的时候，只有工厂方法和产品的接口，也就是说只需要提供 Product Interface 和 Concrete Factory 就可以产生自己需要的对象和方法，Java 的高内聚低耦合的特性表现的一览无遗，哈哈。

3.写在最后

这篇博客主要讲了下抽象工厂的模式。只要记好对应的类图，在后续的开发的过程可以使用这个对应的设计的模式。