设计模式6 - 抽象工厂模式【Abstract Factory Pattern】

抽象工厂模式

定义：
所有形态的工厂模式中最为抽象和最具一般性的一种形态，为创建一组相关或相互依赖的对象提供一个接口，而且无需指定他们的具体类。

例子：

分析：
接上一节”女娲造人例子”,有了丹炉去造人了，但是问题来了，新增了一个需求，造的人需要增加性别。简单的说，就是在工厂里面，生产的每一个实体，里面都有一个获取性别的方法。
同时：
也要也要增加分为男性和女性的工场。

直接上代码：

人类模块：

/**
* 人类接口
*/
public interface Human { 
    public void laugh(); 
    public void cry(); 
    public void talk(); 
    public void sex(); 
} 

/**
* 定义为抽象类,因为子类要定义性别
*/
public abstract class AbstractYellowHuman implements Human{ 

    public void cry() { 
         System.out.println("黄色人类会哭"); 
    } 

    public void laugh() { 
         System.out.println("黄色人类会大笑，幸福呀！"); 
    } 
    public void talk() { 
         System.out.println("黄色人类会说话，一般说的都是双字节"); 
    } 
} 

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

/**
* 男性黄种人
*/
public class YellowMaleHuman extends AbstractYellowHuman { 

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

---

工厂模块：

/**
*工厂类接口
*/
public interface HumanFactory { 
    //制造黄色人类
    public Human createYellowHuman(); 

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

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

/**
* 抽象工厂
*/
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; 
 } 
} 

/**
* 男性创建工厂
*/
public class MaleHumanFactory extends AbstractHumanFactory { 

    //创建一个男性黑种人
    public Human createBlackHuman() { 
         return super.createHuman(HumanEnum.BlackMaleHuman); 
    } 

    //创建一个男性白种人
    public Human createWhiteHuman() { 
         return super.createHuman(HumanEnum.WhiteMaleHuman); 
    } 

    //创建一个男性黄种人
    public Human createYellowHuman() { 
         return super.createHuman(HumanEnum.YelloMaleHuman); 
    } 
} 

/**
* 女性创建工厂
*/
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); 
  } 
} 

---

主程序，开始造人

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

         .......
 } 
} 

总结：

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