这个类图比较简单，也很直观。一个接口，多个抽象类，然后多个实现类。每个人种都是抽象类，性别是在各个实现类中实现的。HumanFactory定义了三个方法，分别创建三个不同肤色的人类。
人种有三个抽象类，负责人种的抽象属性定义：肤色和语言，
人种接口
public interface Human { void getTalk(); void getColor(); void getSex(); }人种有三个抽象类，负责人种的抽象属性定义 黑色人种
public abstract class AbstractBlackHuman implements Human{ @Override public void getTalk() { System.out.println("黑人说话听不懂"); } @Override public void getColor() { System.out.println("我的皮肤是黑色的"); } }白色人种
public abstract class AbstractWhiteHuman implements Human{ @Override public void getTalk() { System.out.println("我是一个白人"); } @Override public void getColor() { System.out.println("我的皮肤是白色的"); } }黄色人种
public abstract class AbstractYellowHuman implements Human{ @Override public void getTalk() { System.out.println("黄种人说话最好听"); } @Override public void getColor() { System.out.println("我的皮肤是黄色的"); } }每个抽象类都有两个实现，分别实现公共的细节最具体的事物。 定义一个黑人女性
public class FamaleBlackHuman extends AbstractYellowHuman { @Override public void getSex() { System.out.println("黑人女性"); } }黑人男性人种
public class MaleBlackHuman extends AbstractYellowHuman { @Override public void getSex() { System.out.println("黑色人种男性"); } }八卦炉的定义，分别创建三个不同肤色的人
public interface HummanFactory { public Human createBlackHuman(); public Human createYellowHuman(); public Human createWhiteHuman(); }八卦炉的细分，生产女性的八卦炉
public class FamaleFactory implements HummanFactory { @Override public Human createBlackHuman() { return new FamaleBlackHuman(); } @Override public Human createYellowHuman() { return new FamaleYellowHuman(); } @Override public Human createWhiteHuman() { return null; } }生产男性的八卦炉
public class MaleFactory implements HummanFactory { @Override public Human createBlackHuman() { return new MaleBlackHuman(); } @Override public Human createYellowHuman() { return new MaleBlackHuman(); } @Override public Human createWhiteHuman() { return null; } }女娲重造人类
public class NvWa { public static void main(String[] args){ //第一条生产线，男性生产线 HummanFactory balckMale = new MaleFactory(); //创建人类 Human human = balckMale.createBlackHuman(); human.getSex(); } }为创建一组相关或相互依赖的对象提供一个接口，而且无须指定他们的具体类。
抽象工厂是工厂模式的升级版本，在有多个业务品种，业务分类时，通过抽象工厂模式产生需要的对象是一种非常号的解决方式。
两个抽象类产品类可以有关系，例如共同继承和实现一个抽象类接口。
定义抽象产品类
public abstract class AbstractProductA { /** * 共享方法 */ public void shareMethod(){} /** * 每个产品相同的方法， 不同的实现 */ public abstract void doSomeThimg(); }产品类A1的实现类
public class ProductA1 extends AbstractProductA{ @Override public void doSomeThimg() { System.out.println("产品A1的实现"); } }产品类A2的实现
public class ProductA2 extends AbstractProductA{ @Override public void doSomeThimg() { System.out.println("产品A2的实现"); } }抽象工厂类AbstractCreator的职责是定义每个工厂要实现的功能。
public abstract class AbstractCreator { //创建A产品类 public abstract AbstractProductA createProductA(); //创建B产品类 public abstract AbstractProductB createProductB(); //todo 有N个产品类，在抽象工厂类中就应该有N个创建方法 }创建一个产品是由实现类来完成的，Creator1和Creator2 产品等级1的实现
public class Creator1 extends AbstractCreator { //创建产品等级为1 的A类产品 @Override public AbstractProductA createProductA() { return new ProductA1(); } //创建产品等级为1 的B类产品 @Override public AbstractProductB createProductB() { return new ProductB1(); } //todo 有M个产品等级就应该有M个实现工厂类，在每个实现工厂中，实现不同产品类的生成任务。 }产品等级2的实现
public class Creator2 extends AbstractCreator { //创建产品等级为2的A类产品 @Override public AbstractProductA createProductA() { return new ProductA2(); } //创建产品等级为2的B类产品 @Override public AbstractProductB createProductB() { return new ProductB2(); } }场景类
public class Client { //场景类 public static void mian(String[] args){ AbstractCreator abstractCreator = new Creator1(); AbstractCreator abstractCreator12 = new Creator2(); //产生A1对象 abstractCreator.createProductA(); //产生A2对象 abstractCreator12.createProductA(); //产生B1对象 abstractCreator.createProductB(); //产生B2对象 abstractCreator12.createProductB(); } }在产品类上，没有一个方法与实现类有关系，对于一个产品来说，我们只要知道它的工厂方法就可以直接产生一个产品对象，无须关心它的实现类。
