简单工厂，工厂方法，抽象工厂都属于设计模式中的创建型模式。其主要功能都是帮助我们把对象的实例化部分抽取了出来，优化了系统的架构，并且增强了系统的扩展性。
大白话
如果简单工厂是用来生产”东西“的，那任何”东西“的子类，比如汽车，自行车，轮船，洗发水都是可以被生产的，但此处简单工厂的压力太大了啊，任何”东西“的子类都可以被生产，负担太重，所以一般对简单工厂类也有种称呼，叫”上帝类“。
而工厂方法模式就很好的减轻了工厂类的负担，把某一类/某一种东西交由一个工厂生产，同时增加某一类”东西“并不需要修改工厂类，只需要添加生产这类”东西“的工厂即可，使得工厂类符合开放-封闭原则。
对于”东西“的分类，有时候不能光是横向的分类，从另一个角度也是可以分类的，不知道这句话的意思能不能懂，打个比方：汽车可以根据品牌分为奔驰、奥迪，也可以根据类别分为普通三厢车和SUV车，如果用工厂方法来描述的话，奔驰车工厂有一个方法即生产奔驰车，奥迪车工厂有一个方法生产奥迪车，但在有多重分类的情形下，这样写已经不够用，不符合实际了，这个时候需要用到抽象工厂模式，即奥迪车工厂有两个方法，一个方法是生产普通三厢奥迪车，另一个方法是生产SUV奥迪车。奔驰车工厂有两个方法，一个方法是生产普通三厢奔驰车，另一个方法是生产SUV奔驰车。
上面即工厂方法模式和抽象工厂模式的应用场景，因为这两者很像，所以概念上不容易区分，可以这么说，工厂方法模式是一种极端情况的抽象工厂模式，而抽象工厂模式可以看成是工厂方法模式的一种推广。
再说下抽象工厂模式，此处的抽象工厂接口应该是有两个方法，一个是生成普通三厢车，一个是生产SUV车，可以说，生产的”东西“已经被限定住了，因此你不能生产某品牌汽车外的其他”东西“，因而可以理解成使用抽象工厂模式不能新增新的”东西“（在简单工厂和工厂方法中理论上都是可以新增任意”东西“的）。
简单工厂
简单工厂模式的工厂类一般是使用静态方法，通过接收的参数的不同来返回不同的对象实例。不修改代码的话，是无法扩展的。
简单工厂代码示例：
public interface Product{
}
public class ProductA implements Product{
public ProductA(){
System.out.println("生产ProductA ...");
}
}
public class ProductB implements Product{
public ProductB(){
System.out.println("生产ProductB ...");
}
}
public class ProductC implements Product{
public ProductC(){
System.out.println("生产ProductC ...");
}
}
public class SimpleFactory{
public Product getProduct(String name){
if(name.equals("A")){
return new ProductA();
}
else if(name.equals("B")){
return new ProductB();
}
return new ProductC();
}
}
//测试类
public class FactoryTest {
public static void main(String[] args) {
//厂商1负责生产产品A1、B1
SimpleFactory sf = new SimpleFactory();
Product p1= sf.getProduct("A");
Product p2 = sf.getProduct("B");
}
}
工厂方法
工厂方法是针对每一种产品提供一个工厂类。通过不同的工厂实例来创建不同的产品实例。在同一等级结构中，支持增加任意产品。
工厂方法代码示例：
public interface Product{
}
public interface Creator{
public Product factory();
}
public class ConcreteProduct1 implements Product{
public ConcreteProduct1(){
System.out.println("ConcreteProduct1被创建");
}
}
public class ConcreteProduct2 implements Product{
public ConcreteProduct2(){
System.out.println("ConcreteProduct2被创建");
}
}
public class ConcreteCreator1 implements Creator{
public Product factory(){
return new ConcreteProduct1();
}
}
public class ConcreteCreator2 implements Creator{
public Product factory(){
return new ConcreteProduct2();
}
}
public class FactoryTest{
private static Creator creator1, creator2;
private static Product prod1, prod2;
public static void main(String[] args){
creator1 = new ConcreteCreator1();
prod1 = creator1.factory();
System.out.println("----------------------------");
creator2 = new ConcreteCreator2();
prod2 = creator2.factory();
}
}
抽象工厂
抽象工厂是应对产品族概念的。比如说，每个汽车公司可能要同时生产轿车，货车，客车，那么每一个工厂都要有创建轿车，货车和客车的方法。
应对产品族概念而生，增加新的产品线很容易，但是无法增加新的产品。
抽象工厂代码示例：
public interface IProductA{
public void method();
}
public interface IProductB{
public void method();
}
//由于已经设计好A1由厂商1生产，故以下输出代码有“厂商x”
public class ProductA1 implements IProductA{
public void method() {
System.out.println("厂商1 生产ProductA1 ...");
}
}
public class ProductA2 implements IProductA{
public void method() {
System.out.println("厂商2 生产ProductA2 ...");
}
}
public class ProductB1 implements IProductB{
public void method() {
System.out.println("厂商1 生产ProductB1 ...");
}
}
public class ProductB2 implements IProductB{
public void method() {
System.out.println("厂商2 生产ProductB2 ...");
}
}
//不同的厂商负责自己牌子产品的生产
public abstract class Factory1{
abstract IProductA getProductA1();
abstract IProductB getProductB1();
}
public abstract class Factory2{
abstract IProductA getProductA2();
abstract IProductB getProductB2();
}
//具体的工厂用来生产相关的产品
public class ConcreteFactory1 extends Factory1{
public IProductA getProductA1() {
return new ProductA1();
}
public IProductB getProductB1() {
return new ProductB1();
}
}
public class ConcreteFactoryB extends Factory2{
public IProductA getProductA2() {
return new ProductA2();
}
public IProductB getProductB2() {
return new ProductB2();
}
}
//测试类
public class FactoryTest {
public static void main(String[] args) {
//厂商1负责生产产品A1、B1
Factory1 factory1 = new ConcreteFactory1();
IProductA productA1 = factory1.getProductA1();
IProductB productB1 = factory1.getProductB1();
productA1.method();
productB1.method();
//厂商2负责生产产品A2、B2
Factory2 factory2 = new ConcreteFactoryB();
IProductA productA2 = factory2.getProductA2();
IProductB productB2 = factory2.getProductB2();
productA2.method();
productB2.method();
}
}
三者的区别
简单工厂 ： 用来生产同一等级结构中的任意产品。（在遵循开闭原则的条件下，对于增加新的产品，无能为力）。
工厂方法 ：用来生产同一等级结构中的固定产品。（支持增加任意产品） 。
抽象工厂 ：用来生产不同产品族的全部产品。（对于增加新的产品，无能为力；支持增加产品族） 。
总结
工厂模式中，重要的是工厂类，而不是产品类。产品类可以是多种形式，多层继承或者是单个类都是可以的。但要明确的，工厂模式的接口只会返回一种类型的实例，这是在设计产品类的时候需要注意的，最好是有父类或者共同实现的接口。使用工厂模式，返回的实例一定是工厂创建的，而不是从其他对象中获取的。工厂模式返回的实例可以不是新创建的，返回由工厂创建好的实例也是可以的。
原文地址：http://blog.csdn.net/superbeck/article/details/4446177#comments
http://www.cnblogs.com/devinzhang/archive/2011/12/19/2293160.html