抽象工厂模式--AbstractFactory

　　模拟场景：在上次的工厂设计模式中，女娲造了一群人。后面觉得不合适，世界上的人都好像傀儡，没有任何感情。所以她打算重新造人，让人类有性别之分：男、女。但是女娲不可能全部推倒重做吧，这个时候就要进行旧物回收利用了。

　　在这里我们先进行分析一下，首先是human这个类，因为这里涉及到了sex、color、doSomething三个方法，很明显这些方法要定义到human这个接口中，具体是什么sex、什么color都是由子类去实现。那么就肯定有Yellow、White、Black三种不同肤色的human，所以要创建YellowHuman、WhiteHuman、BlackHuman三个类，但是考虑下，实现了Human接口，是否意味着要把这三个接口全部都实现呢？（下面只以YellowHuman为例进行说明，其他两个是一样的）

　　其实不是，因为分析一下就知道，这里涉及到sex，那么femaleYellowHuman和maleYellowHuman只是sex不同而已，其他的像color和doSomething的操作时一样的。所以这个时候YellowHuman不能定义成普通的类，因为如果是普通的类的话就需要实现接口的全部方法。那么我们就可以使用abstract类了。不要忘记了，抽象类中是可以存在非抽象方法的，所以把共有的方法或者属性写到抽象类中，不实现getSex()方法即可。至于具体操作交给子类去实现即可。

接下来是工厂factory。工厂的操作就简单多了，在这里，虽然要创建不同肤色不同性别的human，都是会发现，其实需要创建两个factory，那就是以性别来区分（FemaleHumanFactory、MaleHumanFactory），因为我们生成的human中，最后是生成FemaleXXXHuman、MaleXXXHuman。

　　如下代码：（也是以YellowHuman为例，其他操作类似）

　　Human： 

package com.zqz.dp.abstractfactory.human;
/**
 * @author Qin 定义human的接口，human都有一些相同的属性，如人都有肤色、性别等等
 */
public interface Human {
         public void getColor(); // human的肤色
         public void getSex(); // human的性别
         public void doSomething(); // human可以做事
} 

　　AbstractYellowHuman： 

package com.zqz.dp.abstractfactory.human;
/**
 * @author Qin
 * 定义一个黄种人的抽象类，所有的黄种人有着相同的肤色，可以做一样的事情，不同的只是有性别之分而已
 * 所以此抽象类来定义相同的属性
 */
public abstract class AbstractYellowHuman implements Human {
         @Override
         public void getColor() {
                   System.out.println("黄种人的肤色是黄色的。。。");
         }
         @Override
         public void doSomething() {
                   System.out.println("我是黄种人。。。");
         }
} 

　　FemaleYellowHuman： 

package com.zqz.dp.abstractfactory.human;
/**
 * @author Qin
 * 定义女性黄种人，只需要覆写其中的性别即可，黄种人除了性别有着其他的共有属性
 */
public class FemaleYellowHuman extends AbstractYellowHuman {
         @Override
         public void getSex() {
                   System.out.println("我是女黄种人。。。");
         }
} 

　　MaleYellowHuman： 

package com.zqz.dp.abstractfactory.human;
/**
 * @author Qin
 * 定义男性黄种人，只需要覆写其中的性别即可，黄种人除了性别有着其他的共有属性
 */
public class MaleYellowHuman extends AbstractYellowHuman {
         @Override
         public void getSex() {
                   System.out.println("我是男黄种人。。。");
         }
} 

　　HumanFactory： 

package com.zqz.dp.abstractfactory.factory;
import com.zqz.dp.abstractfactory.human.Human;
/**
 * @author Qin
 * human工厂，用来创建不同肤色的human，下面定义了三个肤色，具体生成的是female还是mela交给子类去实现
 */
public interface HumanFactory {
         public Human createYellowHuman(); // 生成黄种人的实现
         public Human createWhiteHuman(); // 生成白种人的实现
         public Human createBlackHuman(); // 生成黑种人的实现
} 

　　FemaleHumanFactory： 

package com.zqz.dp.abstractfactory.factory;
import com.zqz.dp.abstractfactory.human.AbstractBlackHuman;
import com.zqz.dp.abstractfactory.human.AbstractWhiteHuman;
import com.zqz.dp.abstractfactory.human.AbstractYellowHuman;
import com.zqz.dp.abstractfactory.human.FemaleBlackHuman;
import com.zqz.dp.abstractfactory.human.FemaleWhiteHuman;
import com.zqz.dp.abstractfactory.human.FemaleYellowHuman;
/**
 * @author Qin 创建不同肤色，但是性别为female（女）的human
 */
public class FemaleHumanFactory implements HumanFactory {
         @Override
         public AbstractYellowHuman createYellowHuman() {// 返回黄种人对象
                   return new FemaleYellowHuman(); // 生成女性黄种人
         }
         @Override
         public AbstractWhiteHuman createWhiteHuman() {// 返回白种人对象
                   return new FemaleWhiteHuman(); // 生成女性白种人
         }
         @Override
         public AbstractBlackHuman createBlackHuman() {// 返回黑种人对象
                   return new FemaleBlackHuman(); // 生成女性黑种人
         }
} 

　　MaleHumanFactory： 

package com.zqz.dp.abstractfactory.factory;
import com.zqz.dp.abstractfactory.human.AbstractBlackHuman;
import com.zqz.dp.abstractfactory.human.AbstractWhiteHuman;
import com.zqz.dp.abstractfactory.human.AbstractYellowHuman;
import com.zqz.dp.abstractfactory.human.MaleBlackHuman;
import com.zqz.dp.abstractfactory.human.MaleWhiteHuman;
import com.zqz.dp.abstractfactory.human.MaleYellowHuman;
/**
 * @author Qin 创建不同肤色，但是性别为male（男）的human
 */
public class MaleHumanFactory implements HumanFactory {
         @Override
         public AbstractYellowHuman createYellowHuman() {     //返回黄种人对象
                   return new MaleYellowHuman(); // 生成男性黄种人
         }
         @Override
         public AbstractWhiteHuman createWhiteHuman() {      //返回白种人对象
                   return new MaleWhiteHuman(); // 生成男性白种人
         }
         @Override
         public AbstractBlackHuman createBlackHuman() {         //返回黑种人对象
                   return new MaleBlackHuman(); // 生成男性黑种人
         }
} 

　　NvWa: 

package com.zqz.dp.abstractfactory.client;
import com.zqz.dp.abstractfactory.factory.FemaleHumanFactory;
import com.zqz.dp.abstractfactory.factory.HumanFactory;
import com.zqz.dp.abstractfactory.factory.MaleHumanFactory;
import com.zqz.dp.abstractfactory.human.Human;
/**
 * @author Qin NvWa类，开始生产不同性别的人类
 */
public class NvWa {
         public static void main(String[] args) {
                   create();
         }
         public static void create() {
                   /**
                    * 创建两个工厂，生成female、male的human
                    */
                   HumanFactory femaleFactory = new FemaleHumanFactory(); // 生成female的human工厂
                   HumanFactory maleFactory = new MaleHumanFactory(); // 生成male的human工厂
                   /**
                    * 开始创建不同sex、不同肤色的human
                    */
                   Human femaleYellowHuman = femaleFactory.createYellowHuman();   //创建female黄种人
                   Human maleYellowHuman = maleFactory.createYellowHuman(); //创建male黄种人
                   femaleYellowHuman.getSex();                  //取得female黄种人的性别
                   maleYellowHuman.getSex();            //取得male黄种人的性别
                   /**
                    * 生成其他肤色的human、一样的操作，略去
                    */
         }
} 

　　抽象工厂的定义：未创建一组相关或者相互依赖的对象提供一个接口，而且无需指定它们的具体类。

抽象工厂的优点：

　　封装性，每个产品的实现类其他模块不需要关心，关系的只是工厂类是哪个，只要知道工厂类是哪个，我就可以创建出一些需要的对象。

抽象工厂的缺点：

　　横向扩展方便，即如果我们要定义一个中性的human、扩展是很方便的。只是纵向扩展很麻烦。如果要再创建一种其他肤色的human时。

抽象工厂的使用场景：

　　抽象工厂定义了一系列的产品，如果想对这一系列的产品进行拓展，或者想要替换掉一系列的产品，生成新的系列操作，或者控制系列产品的生产过程，那么就用抽象工厂。

一个对象族（或者一组没有任何关系的对象）都有相同的约束，则可以使用抽象工厂。