定义：为创建一组相关或相互依赖的对象提供一个接口，而且无须指定他们的具体类。

我的理解:抽象工厂模式是工厂模式的升级，它针对多个业务品种，业务分类时通过抽象工厂模式来解决。

就好比工厂中的流水线工作一样。

一个例子：
还是继续女娲造人的故事，女娲在制造出白人、黑人、黄种人之后，又想创造出男人和女人。那么如何来解决这个需求呢？

解决方案:
1、定义一个接口Human，提供getSkin()，talk(),getSex()方法。
2、使用抽象类继承自Human,分别实现不同肤色人的共有方法。
3、各种肤色的人拥有男性和女性类。
4、定义一个创建工厂接口，创建男性和女性工厂的类来实现不同种类的男性和女性的创建
工厂模式只要你知道创建工厂的类及方法，就能创造出一个与之无关的其他类，而不必去管它具体是怎么创建出来的。

public class HumanTest {
	public static void main(String[] args) {
		System.out.println("--------女性工厂-------------------");
		FemaleYellowHuman femaleYellow = (FemaleYellowHuman) new FemaleFactory().createYellowHuman();
		femaleYellow.getSex();
		femaleYellow.getSkin();
		femaleYellow.talk();
		System.out.println("--------男性工厂---------------");
		MaleYellowHuman maleYellow = (MaleYellowHuman) new MaleFactory().createYellowHuman();
		maleYellow.getSex();
		maleYellow.getSkin();
		maleYellow.talk();
	}
}
interface Human{
	//获取肤色
	void getSkin();
	//说话语言
	void talk();
	//性别
	void getSex();
}
abstract class AbstractBlack implements Human{
	public void getSkin(){
		System.out.println("我是黑人,拥有黑色的皮肤...");
	}
	@Override
	public void talk() {
		System.out.println("我是黑人,说的是非洲语...");
	}
}
abstract class AbstractYellow implements Human{
	public void getSkin(){
		System.out.println("我是黄种人,拥有黄色的皮肤...");
	}
	@Override
	public void talk() {
		System.out.println("我是黄种人,说的是汉语...");
	}
}
abstract class AbstractWhite implements Human{
	public void getSkin(){
		System.out.println("我是白种人,拥有白色的皮肤...");
	}
	@Override
	public void talk() {
		System.out.println("我是白种人,说的是英语...");
	}
}
class FemaleBlackHuman extends AbstractBlack{

	@Override
	public void getSex() {
		System.out.println("我是非洲女人...");
	}
}
class MaleBlackHuman extends AbstractBlack{

	@Override
	public void getSex() {
		System.out.println("我是非洲男人...");
	}
}
class FemaleYellowHuman extends AbstractYellow{
	@Override
	public void getSex() {
		System.out.println("我是中国女人...");
	}
}
class MaleYellowHuman extends AbstractYellow{
	@Override
	public void getSex() {
		System.out.println("我是中国男人...");
	}
}
class FemaleWhiteHuman extends AbstractWhite{
	@Override
	public void getSex() {
		System.out.println("我是美国女人...");
	}
}
class MaleWhiteHuman extends AbstractWhite{
	@Override
	public void getSex() {
		System.out.println("我是美国男人...");
	}
}
interface HumanFactory{
	//创建黑人
	Human createBlackHuman();
	//创建黄种人
	Human createYellowHuman();
	//创建白人
	Human createWhiteHuman();
}
class FemaleFactory implements HumanFactory{

	@Override
	public Human createBlackHuman() {
		// TODO Auto-generated method stub
		return new FemaleBlackHuman();
	}

	@Override
	public Human createYellowHuman() {
		// TODO Auto-generated method stub
		return new FemaleYellowHuman();
	}

	@Override
	public Human createWhiteHuman() {
		// TODO Auto-generated method stub
		return new FemaleWhiteHuman();
	}
}
class MaleFactory implements HumanFactory{

	@Override
	public Human createBlackHuman() {
		// TODO Auto-generated method stub
		return new MaleBlackHuman();
	}

	@Override
	public Human createYellowHuman() {
		// TODO Auto-generated method stub
		return new MaleYellowHuman();
	}

	@Override
	public Human createWhiteHuman() {
		// TODO Auto-generated method stub
		return new MaleWhiteHuman();
	}
}

抽象类的通用模式;

UML类图:

说明：抽象工厂模式具有很好的封装性，它的一般模式是:一个接口，多个抽象类，N个实现类。
他的产品族扩展比较困难，但是产品的等级易扩展。

public class AbstractFactoryTest {
	 public static void main(String[] args) {
		System.out.println("---------等级1，的A,B两个产品-------------");
		IProduct c1 = new Creator1();
		ProductA1 pa1 = (ProductA1) c1.createA();
		ProductB1 pb1 = (ProductB1) c1.createB();
		pa1.Method();
		pb1.Method();
		System.out.println("---------等级2，的A,B两个产品-------------");
		IProduct c2 = new Creator2();
		ProductA2 pa2 = (ProductA2) c2.createA();
		ProductB2 pb2 = (ProductB2) c2.createB();
		pa2.Method();
		pb2.Method();
	 }
}
interface IProduct{
	AbstractProductA createA();
	AbstractProductB createB();
}
abstract class AbstractProductA{
	public void shareMethod(){
		System.out.println("生产产品所共有的方法....");
	}
	//生产产品不同的方法
	public abstract void Method();
}
abstract class AbstractProductB{
	public void shareMethod(){
		System.out.println("生产产品所共有的方法....");
	}
	//生产产品不同的方法
	public abstract void Method();
}
class ProductA1 extends AbstractProductA{

	@Override
	public void Method() {
		System.out.println("生产产品---A1---的方法 ....");
	}
	
}
class ProductB1 extends AbstractProductB{
	@Override
	public void Method() {
		System.out.println("生产产品---B1---的方法 ....");
	}
}
class ProductA2 extends AbstractProductA{

	@Override
	public void Method() {
		System.out.println("生产产品---A2---的方法 ....");
	}
	
}
class ProductB2 extends AbstractProductB{
	@Override
	public void Method() {
		System.out.println("生产产品---B2---的方法 ....");
	}
}
class Creator1 implements IProduct{
	//生产等级1产品A
	@Override
	public AbstractProductA createA() {
		// TODO Auto-generated method stub
		return new ProductA1();
	}
	//生产等级1产品B
	@Override
	public AbstractProductB createB() {
		// TODO Auto-generated method stub
		return new ProductB1();
	}
	
}
class Creator2 implements IProduct{
	//生产等级1产品A
	@Override
	public AbstractProductA createA() {
		// TODO Auto-generated method stub
		return new ProductA2();
	}
	//生产等级1产品B
	@Override
	public AbstractProductB createB() {
		// TODO Auto-generated method stub
		return new ProductB2();
	}
	
}