设计模式之（四）------抽象工厂模式

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

3个抽象类 YellowHuman BlackHuman WhiteHuman 在抽象工厂模式中叫做产品等级，6个实现类（FemaleYellowHuman MaleYellowHuman FemaleBlackHuman MaleBlackHuman FemaleWhiteHuman MaleWhiteHuamn ）叫做产品族。
其中抽象工厂AbstractHumanFactory 只有一个createHuman 的方法。下面我们来看程序实现：

package com.fc.AbstractFactory;

public interface IHumann {
 public void  laugh();
 public  void talk();
 public  void sex();
}

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

package com.fc.AbstractFactory.dengji;

import com.fc.AbstractFactory.IHumann;

public abstract class AbstractYellowHuman implements IHumann{

    public void laugh() {
        System.out.println("黄色人类会笑");

    }

    public void talk() {
        System.out.println("黄色人类说话");

    }

}

其他两个与这个类似，这样三个抽象类就实现完了，然后就是那6个实现类了。
我们先来看女性黄色人种的实现类：

package com.fc.AbstractFactory.pinzu;

import com.fc.AbstractFactory.dengji.AbstractYellowHuman;


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

男性黄色人种：

package com.fc.AbstractFactory.pinzu;

import com.fc.AbstractFactory.dengji.AbstractYellowHuman;


public class YellowMaleHuman extends AbstractYellowHuman{

    public void sex() {
        System.out.println("该黄种人的性别是男。。。");

    }

}

女性黑色人种：

package com.fc.AbstractFactory.pinzu;

import com.fc.AbstractFactory.dengji.AbstractBlackHuman;


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

男性黑色人种：

package com.fc.AbstractFactory.pinzu;

import com.fc.AbstractFactory.dengji.AbstractBlackHuman;


public class BlackMaleHuman extends AbstractBlackHuman{

    public void sex() {
        System.out.println("该黑人的性别是男。。。");

    }

}

女性白色人种：

package com.fc.AbstractFactory.pinzu;

import com.fc.AbstractFactory.dengji.AbstractWhiteHuman;


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

男性白色人种：

package com.fc.AbstractFactory.pinzu;

import com.fc.AbstractFactory.dengji.AbstractWhiteHuman;


public class WhiteMaleHuman extends AbstractWhiteHuman{

    public void sex() {
        System.out.println("该白人的性别是男。。。");

    }

}

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

package com.fc.AbstractFactory;

public enum HumanEnum {

  YelloMaleHuman("com.fc.AbstractFactory.pinzu.YellowMaleHuman"),
  YelloFemalHuman("com.fc.AbstractFactory.pinzu.YellowFemaleHuman"),
  WhiteFemalHuman("com.fc.AbstractFactory.pinzu.WhiteFemaleHuman"),
  WhiteMaleHuman("com.fc.AbstractFactory.pinzu.WhiteMaleHuman"),
  BlackFemalHuman("com.fc.AbstractFactory.pinzu.BlackFemaleHuman"),
  BlackMaleHuman("com.fc.AbstractFactory.pinzu.BlackMaleHuman");
private String value = "";
    //定义构造函数，目的是Data(value) 类型的相匹配
    private HumanEnum(String value){
     this. value = value;
     }
    public String getValue(){
     return this. value;
     }
}

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

package com.fc.AbstractFactory;

public interface IHumanFatory {
    //制造黄色人类
    public IHumann createYellowHuman();
    //制造一个白色人类
    public IHumann createWhiteHuman();
    //制造一个黑色人类
    public IHumann createBlackHuman();
}

然后看抽象类：

package com.fc.AbstractFactory;

import com.fc.factory.Human;

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

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

package com.fc.AbstractFactory;

 public class MaleHumanFactory extends AbstractHumanFactory{


public IHumann createYellowHuman() {

    return super.createHuman(HumanEnum.YelloMaleHuman);
}

public IHumann createWhiteHuman() {

    return super.createHuman(HumanEnum.WhiteMaleHuman);
}

public IHumann createBlackHuman() {

    return super.createHuman(HumanEnum.BlackMaleHuman);
}
}

女性工厂，只创建女性：

package com.fc.AbstractFactory;

public class FemaleHumanFactory extends AbstractHumanFactory{

    public IHumann createYellowHuman() {
        // TODO Auto-generated method stub
        return super.createHuman(HumanEnum.YelloFemalHuman);
    }

    public IHumann createWhiteHuman() {
        // TODO Auto-generated method stub
        return super.createHuman(HumanEnum.WhiteFemalHuman);
    }

    public IHumann createBlackHuman() {
        // TODO Auto-generated method stub
        return super.createHuman(HumanEnum.BlackFemalHuman);
    }

}

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

package com.fc.AbstractFactory;

public class NvWa {

    /**
     * @param args
     */
    public static void main(String[] args) {

         //第一条生产线，男性生产线
         IHumanFatory maleHumanFactory = new MaleHumanFactory();
         //第二条生产线，女性生产线
         IHumanFatory femaleHumanFactory = new FemaleHumanFactory();
         //生产线建立完毕，开始生产人了:
         IHumann maleYellowHuman = maleHumanFactory.createYellowHuman();
         IHumann femaleYellowHuman = femaleHumanFactory.createYellowHuman();
         maleYellowHuman.talk();
         maleYellowHuman.laugh();
         femaleYellowHuman.sex();
         /*
         * .....
         * 后面你可以续了
         */

    }

}

输出结果：
*黄色人类说话
黄色人类会笑
该黄种人的性别为女…*