故事会-设计模式-抽象工厂

6. 抽象工厂模式【Abstract Factory Pattern】
 好了，我们继续上一节课，上一节讲到女娲造人，人是造出来了，世界时热闹了，可是
 低头一看，都是清一色的类型，缺少关爱、仇恨、喜怒哀乐等情绪，人类的生命太平淡了，
 女娲一想，猛然一拍脑袋，Shit！忘记给人类定义性别了，那怎么办？抹掉重来，然后就把
 人类重新洗牌，准备重新开始制造人类。
 由于先前的工作已经花费了很大的精力做为铺垫，也不想从头开始了，那先说人类
 （Product 产品类）怎么改吧，好，有了，给每个人类都加一个性别，然后再重新制造，这
 个问题解决了，那八卦炉怎么办？只有一个呀，要么生产出全都是男性，要不都是女性，那
 不行呀，有了，把已经有了一条生产线——八卦炉（工厂模式中的Concrete Factory）拆
 开，于是女娲就使用了“八卦拷贝术”，把原先的八卦炉一个变两个，并且略加修改，就成
 了女性八卦炉（只生产女性，一个具体工厂的实现类）和男性八卦炉（只生产男性，又一个
 具体工厂的实现类），这个过程的类图如下：
 先看人类（也就是产品）的类图：
 这个类图也比较简单，Java 的典型类图，一个接口，几个抽象类，然后是几个实现类，
 没啥多说的，其中三个抽象类在抽象工厂模式中是叫做产品等级，六个实现类是叫做产品族，
 这个也比较好理解，实现类嘛是真实的产品，一个叫产品，多了就叫产品族，然后再看工厂
 类：
 您的设计模式
 第 33 页
 其中抽象工厂只实现了一个createHuman 的方法，目的是简化实现类的代码工作量，这
 个在讲代码的时候会说。这里还使用了Jdk 1.5 的一个新特性Enum 类型，其实这个完全可
 以类的静态变量来实现，但我想既然是学习就应该学有所获得，即使你对这个模式非常了解，
 也可能没用过Enum 类型，也算是一个不同的知识点吧，我希望给大家讲解，每次都有新的
 技术点提出来，每个人都会有一点的收获就足够了，然后在具体的项目中使用时，知道有这
 个技术点，然后上baidu 狗狗一下就能解决问题。话题扯远了，我们继续类图，完整的类图
 如下，这个看不大清楚，其实就是上面那两个类图加起来，大家可以看源码中的那个类图文
 件：
 然后类图讲解完毕，我们来看程序实现：
 您的设计模式
 第 34 页
 package com.cbf4life;
 /**
 * @author cbf4Life cbf4life@126.com
 * I'm glad to share my knowledge with you all.
 * 定义一个人类的统称，问题出来了，刚刚定义的时候忘记定义性别了
 * 这个重要的问题非修改不可，否则这个世界上太多太多的东西不存在了
 */
 public interface Human {
 //首先定义什么是人类
 //人是愉快的，会笑的，本来是想用smile表示，想了一下laugh更合适，好长时间
 没有大笑了；
 public void laugh();
 //人类还会哭，代表痛苦
 public void cry();
 //人类会说话
 public void talk();
 //定义性别
 public void sex();
 }
 人类的接口定义好，然后根据接口创建三个抽象类，也就是三个产品等级，实现
 laugh()、cry()、talk()三个方法，以AbstractYellowHuman 为例：
 package com.cbf4life.yellowHuman;
 import com.cbf4life.Human;
 /**
 * @author cbf4Life cbf4life@126.com
 * I'm glad to share my knowledge with you all.
 * 为什么要修改成抽象类呢？要定义性别呀
 */
 public abstract class AbstractYellowHuman implements Human {
 public void cry() {
 System.out.println("黄色人种会哭");
 您的设计模式
 第 35 页
 }
 public void laugh() {
 System.out.println("黄色人种会大笑，幸福呀！");
 }
 public void talk() {
 System.out.println("黄色人种会说话，一般说的都是双字节");
 }
 }
 其他的两个抽象类AbstractWhiteHuman 和AbstractgBlackHuman 与此类似的事项方法，
 不再通篇拷贝代码，大家可以看一下源代码。算了，还是拷贝，反正是电子档的，不想看就
 往下翻页，也成就了部分“懒人”，不用启动Eclipse，还要把源码拷贝进来：
 白种人的抽象类：
 package com.cbf4life.whiteHuman;
 import com.cbf4life.Human;
 /**
 * @author cbf4Life cbf4life@126.com
 * I'm glad to share my knowledge with you all.
 * 白色人人种
 * 为了代码整洁，新建一个包，这里是白种人的天下了
 */
 public abstract class AbstractWhiteHuman implements Human {
 public void cry() {
 System.out.println("白色人种会哭");
 }
 public void laugh() {
 System.out.println("白色人种会大笑，侵略的笑声");
 您的设计模式
 第 36 页
 }
 public void talk() {
 System.out.println("白色人种会说话，一般都是但是单字节！");
 }
 }
 黑种人的抽象类：
 package com.cbf4life.blackHuman;
 import com.cbf4life.Human;
 /**
 * @author cbf4Life cbf4life@126.com
 * I'm glad to share my knowledge with you all.
 * 黑色人种，记得中学学英语，老师说black man是侮辱人的意思，不懂，没跟老外说
 话
 */
 public abstract class AbstractBlackHuman implements Human {
 public void cry() {
 System.out.println("黑人会哭");
 }
 public void laugh() {
 System.out.println("黑人会笑");
 }
 public void talk() {
 System.out.println("黑人可以说话，一般人听不懂");
 }
 }
 三个抽象类都实现完毕了，然后就是些实现类了。其实，你说抽象类放这里有什么意义
 吗？就是不允许你new 出来一个抽象的对象呗，使用非抽象类完全就可以代替，呵呵，杀猪
 杀尾巴，各有各的杀法，不过既然进了Java 这个门就要遵守Java 这个规矩，我们看实现类：
 您的设计模式
 第 37 页
 女性黄种人的实现类：
 package com.cbf4life.yellowHuman;
 /**
 * @author cbf4Life cbf4life@126.com
 * I'm glad to share my knowledge with you all.
 * 女性黄种人
 */
 public class YellowFemaleHuman extends AbstractYellowHuman {
 public void sex() {
 System.out.println("该黄种人的性别为女...");
 }
 }
 男性黄种人的实现类：
 package com.cbf4life.yellowHuman;
 /**
 * @author cbf4Life cbf4life@126.com
 * I'm glad to share my knowledge with you all.
 * 男性黄种人
 */
 public class YellowMaleHuman extends AbstractYellowHuman {
 public void sex() {
 System.out.println("该黄种人的性别为男....");
 }
 }
 女性白种人的实现类：
 package com.cbf4life.whiteHuman;
 /**
 * @author cbf4Life cbf4life@126.com
 * I'm glad to share my knowledge with you all.\
 * 女性白种人
 */
 public class WhiteFemaleHuman extends AbstractWhiteHuman {
 您的设计模式
 第 38 页
 public void sex() {
 System.out.println("该白种人的性别为女....");
 }
 }
 男性白种人的实现类：
 package com.cbf4life.whiteHuman;
 /**
 * @author cbf4Life cbf4life@126.com
 * I'm glad to share my knowledge with you all.
 * 男性白种人
 */
 public class WhiteMaleHuman extends AbstractWhiteHuman {
 public void sex() {
 System.out.println("该白种人的性别为男....");
 }
 }
 女性黑种人的实现类：
 package com.cbf4life.blackHuman;
 /**
 * @author cbf4Life cbf4life@126.com
 * I'm glad to share my knowledge with you all.
 * 女性黑种人
 */
 public class BlackFemaleHuman extends AbstractBlackHuman {
 public void sex() {
 System.out.println("该黑种人的性别为女...");
 }
 }
 您的设计模式
 第 39 页
 男性黑种人的实现类：
 package com.cbf4life.blackHuman;
 /**
 * @author cbf4Life cbf4life@126.com
 * I'm glad to share my knowledge with you all.
 * 男性黑种人
 */
 public class BlackMaleHuman extends AbstractBlackHuman {
 public void sex() {
 System.out.println("该黑种人的性别为男...");
 }
 }
 抽象工厂模式下的产品等级和产品族都已经完成，也就是人类以及产生出的人类是什么
 样子的都已经定义好了，下一步就等着工厂开工创建了，那我们来看工厂类。
 在看工厂类之前我们先看那个枚举类型，这个是很有意思的：
 package com.cbf4life;
 /**
 * @author cbf4Life cbf4life@126.com
 * I'm glad to share my knowledge with you all.
 * 世界上有哪些类型的人，列出来
 * JDK 1.5开始引入enum类型也是目的的，吸引C程序员转过来
 */
 public enum HumanEnum {
 //把世界上所有人类型都定义出来
 YelloMaleHuman("com.cbf4life.yellowHuman.YellowMaleHuman"),
 YelloFemaleHuman("com.cbf4life.yellowHuman.YellowFemaleHuman")
 ,
 WhiteFemaleHuman("com.cbf4life.whiteHuman.WhiteFemaleHuman"),
 WhiteMaleHuman("com.cbf4life.whiteHuman.WhiteMaleHuman"),
 BlackFemaleHuman("com.cbf4life.blackHuman.BlackFemaleHuman"),
 您的设计模式
 第 40 页
 BlackMaleHuman("com.cbf4life.blackHuman.BlackMaleHuman");
 private String value = "";
 //定义构造函数，目的是Data(value)类型的相匹配
 private HumanEnum(String value){
 this.value = value;
 }
 public String getValue(){
 return this.value;
 }
 /*
 * java enum类型尽量简单使用，尽量不要使用多态、继承等方法
 * 毕竟用Clas完全可以代替enum
 */
 }
 我之所以引入Enum 这个类型，是想让大家在看这本书的时候能够随时随地的学到点什
 么，你如果看不懂设计模式，你可以从我的程序中学到一些新的技术点，不用像我以前报着
 砖头似的书在那里啃，看一遍不懂，再看第二遍，然后翻了英文原本才知道，哦~，原来是
 这样滴，只能说有些翻译家实在不懂技术。我在讲解技术的时候，尽量少用专业术语，尽量
 使用大部分人类都能理解的语言。
 Enum 以前我也很少用，最近在一个项目中偶然使用上了，然后才发觉它的好处，Enum
 类型作为一个参数传递到一个方法中时，在Junit 进行单元测试的时候，不用判断输入参数
 是否为空、长度为0 的边界异常条件，如果方法传入的参数不是Enum 类型的话，根本就传
 递不进来，你说定义一个类，定义一堆的静态变量，这也可以呀，这个不和你抬杠，上面的
 代码我解释一下，构造函数没啥好说的，然后是getValue()方法，就是获得枚举类型中一
 个元素的值，枚举类型中的元素也是有名称和值的，这个和HashMap 有点类似。
 然后，我们看我们的工厂类，先看接口：
 package com.cbf4life;
 您的设计模式
 第 41 页
 /**
 * @author cbf4Life cbf4life@126.com
 * I'm glad to share my knowledge with you all.
 * 这次定一个接口，应该要造不同性别的人，需要不同的生产线
 * 那这个八卦炉必须可以制造男人和女人
 */
 public interface HumanFactory {
 //制造黄色人种
 public Human createYellowHuman();
 //制造一个白色人种
 public Human createWhiteHuman();
 //制造一个黑色人种
 public Human createBlackHuman();
 }
 然后看抽象类：
 package com.cbf4life.humanFactory;
 import com.cbf4life.Human;
 import com.cbf4life.HumanEnum;
 import com.cbf4life.HumanFactory;
 /**
 * @author cbf4Life cbf4life@126.com
 * I'm glad to share my knowledge with you all.
 * 编写一个抽象类，根据enum创建一个人类出来
 */
 public abstract class AbstractHumanFactory implements HumanFactory
 {
 /*
 * 给定一个性别人种，创建一个人类出来专业术语是产生产品等级
 */
 protected Human createHuman(HumanEnum humanEnum) {
 Human human = null;
 //如果传递进来不是一个Enum中具体的一个Element的话，则不处理
 if (!humanEnum.getValue().equals("")) {
 try {
 //直接产生一个实例
 您的设计模式
 第 42 页
 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.cbf4life.humanFactory;
 import com.cbf4life.Human;
 import com.cbf4life.HumanEnum;
 /**
 * @author cbf4Life cbf4life@126.com
 * I'm glad to share my knowledge with you all.
 * 男性创建工厂
 */
 public class MaleHumanFactory extends AbstractHumanFactory {
 //创建一个男性黑种人
 public Human createBlackHuman() {
 return super.createHuman(HumanEnum.BlackMaleHuman);
 }
 //创建一个男性白种人
 public Human createWhiteHuman() {
 return super.createHuman(HumanEnum.WhiteMaleHuman);
 }
 //创建一个男性黄种人
 您的设计模式
 第 43 页
 public Human createYellowHuman() {
 return super.createHuman(HumanEnum.YelloMaleHuman);
 }
 }
 女性工厂，只创建女性：
 package com.cbf4life.humanFactory;
 import com.cbf4life.Human;
 import com.cbf4life.HumanEnum;
 /**
 * @author cbf4Life cbf4life@126.com
 * I'm glad to share my knowledge with you all.\
 * 女性创建工厂
 */
 public class FemaleHumanFactory extends AbstractHumanFactory {
 //创建一个女性黑种人
 public Human createBlackHuman() {
 return super.createHuman(HumanEnum.BlackFemaleHuman);
 }
 //创建一个女性白种人
 public Human createWhiteHuman() {
 return super.createHuman(HumanEnum.WhiteFemaleHuman);
 }
 //创建一个女性黄种人
 public Human createYellowHuman() {
 return super.createHuman(HumanEnum.YelloFemaleHuman);
 }
 }
 产品定义好了，工厂也定义好了，万事俱备只欠东风，那咱就开始造吧，哦，不对，女
 娲开始造人了：
 package com.cbf4life;
 您的设计模式
 第 44 页
 import com.cbf4life.humanFactory.FemaleHumanFactory;
 import com.cbf4life.humanFactory.MaleHumanFactory;
 /**
 * @author cbf4Life cbf4life@126.com
 * I'm glad to share my knowledge with you all.
 * 女娲建立起了两条生产线，分别是：
 * 男性生产线
 * 女性生产线
 */
 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 原则，也就是开闭原则，怎
 么说呢，比如就性别的问题，这个世界上还存在双性人，是男也是女的人，那这个就是要在
 您的设计模式
 第 45 页
 我们的产品族中增加一类产品，同时再增加一个工厂就可以解决这个问题，不需要我再来实
 现了吧，很简单的大家自己画下类图，然后实现下。
 那还有没有其他好处呢？抽象工厂模式，还有一个非常大的有点，高内聚，低耦合，在
 一个较大的项目组，产品是由一批人定义开发的，但是提供其他成员访问的时候，只有工厂
 方法和产品的接口，也就是说只需要提供Product Interface 和Concrete Factory 就可以
 产生自己需要的对象和方法，Java 的高内聚低耦合的特性表现的一览无遗，哈哈。
 您的设计模式