一 抽象工厂模式（工厂方法模式请点我）

工厂方法模式和抽象工厂模式不好分清楚，他们的区别如下：
工厂方法模式：
一个抽象产品类，可以派生出多个具体产品类。
一个抽象工厂类，可以派生出多个具体工厂类。
每个具体工厂类只能创建一个具体产品类的实例。
抽象工厂模式：
多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。
一个抽象工厂类，可以派生出多个具体工厂类。
每个具体工厂类可以创建多个具体产品类的实例，也就是创建的是一个产品线下的多个产
品。

区别：
工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。
工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多
个。
工厂方法创建 "一种" 产品，他的着重点在于"怎么创建"，也就是说如果你开发，你的大量
代码很可能围绕着这种产品的构造，初始化这些细节上面。也因为如此，类似的产品之间有
很多可以复用的特征，所以会和模版方法相随。
抽象工厂需要创建一些列产品，着重点在于"创建哪些"产品上，也就是说，如果你开发，你
的主要任务是划分不同差异的产品线，并且尽量保持每条产品线接口一致，从而可以从同一
个抽象工厂继承。
对于 java 来说，你能见到的大部分抽象工厂模式都是这样的：
---它的里面是一堆工厂方法，每个工厂方法返回某种类型的对象。
比如说工厂可以生产鼠标和键盘。那么抽象工厂的实现类（它的某个具体子类）的对象都可
以生产鼠标和键盘，但可能工厂 A 生产的是罗技的键盘和鼠标，工厂 B 是微软的。
 “玩转”Java 系列


这样 A 和 B 就是工厂，对应于抽象工厂；
每个工厂生产的鼠标和键盘就是产品，对应于工厂方法；
用了工厂方法模式，你替换生成键盘的工厂方法，就可以把键盘从罗技换到微软。但是用了
抽象工厂模式，你只要换家工厂，就可以同时替换鼠标和键盘一套。如果你要的产品有几十
个，当然用抽象工厂模式一次替换全部最方便（这个工厂会替你用相应的工厂方法）
所以说抽象工厂就像工厂，而工厂方法则像是工厂的一种产品生产线

下面举一个例子：

类图：

ICat.java

package com.lxj.abstractfactory;

public interface ICat {
	
    public void eat();
    
}

BlackCat.java

package com.lxj.abstractfactory;

public class BlackCat implements ICat {

	@Override
	public void eat() {
       System.out.println("this is BlackCat");
	}

}

WhiteCat.java

package com.lxj.abstractfactory;

public class WhiteCat implements ICat {

	@Override
	public void eat() {
       System.out.println("this is WhiteCat");
	}

}

IDog.java

package com.lxj.abstractfactory;

public interface IDog {

	 public void eat();
	 
}

WhiteDog.java

package com.lxj.abstractfactory;

public class WhiteDog implements IDog {

	@Override
	public void eat() {
        System.out.println("this is WhiteDog");
	}

}

BlackDog.java

package com.lxj.abstractfactory;

public class BlackDog implements IDog {

	@Override
	public void eat() {
        System.out.println("this is BlackDog");
	}

}

IAnimalFactory.java

package com.lxj.abstractfactory;

public interface IAnimalFactory {
	 
	 public ICat createCat();
	 public IDog createDog();
}

WhiteAnimalFactory.java

package com.lxj.abstractfactory;

public class WhiteAnimalFactory implements IAnimalFactory {

	@Override
	public ICat createCat() {
		//创建白猫
		return new WhiteCat();
	}

	@Override
	public IDog createDog() {
		//创建白狗
		return new WhiteDog();
	}

}

BlackAnimalFactory.java

package com.lxj.abstractfactory;

public class BlackAnimalFactory implements IAnimalFactory {

	@Override
	public ICat createCat() {
		//创建黑猫
		return new BlackCat();
	}

	@Override
	public IDog createDog() {
		//创建黑狗
		return new BlackDog();
	}

}

TestAbstractFactory.java

package com.lxj.abstractfactory;

public class TestAbstractFactory {

	public static void main(String[] args) {
		//创建一只白猫
		WhiteAnimalFactory whiteAnimalFactory = new WhiteAnimalFactory();
		ICat whiterCat = whiteAnimalFactory.createCat();
		whiterCat.eat();
		//创建一只黑狗
		BlackAnimalFactory blackAnimalFactory = new BlackAnimalFactory();
		IDog blackDog = blackAnimalFactory.createDog();
		blackDog.eat();
	}

}

运行结果：

this is WhiteCat
this is BlackDog

二 总结

        从上面的例子可以知道，抽象工厂模式中，一个抽象工厂类，可以派生多个具体的工厂类，每个具体工厂类可以创建多个具体的产品类的实例，也就是一个产品线下的多个产品，有多个抽象产品类，每个抽象产品类可以派生多个具体的产品。，而在工厂方法模式中的话，一个抽象工厂类，派生多个具体的工厂类，每个工厂类生产一种产品的实例，一个抽象产品类，派生多个具体的产品类。