简单工厂、工厂方法、抽象工厂的总结-优快云博客

简单工厂，工厂方法，抽象工厂都属于设计模式中的创建型模式。其主要功能都是帮助我们把对象的实例化部分抽取了出来，优化了系统的架构，并且增强了系统的扩展性。

大白话

如果简单工厂是用来生产”东西“的，那任何”东西“的子类，比如汽车，自行车，轮船，洗发水都是可以被生产的，但此处简单工厂的压力太大了啊，任何”东西“的子类都可以被生产，负担太重，所以一般对简单工厂类也有种称呼，叫”上帝类“。
而工厂方法模式就很好的减轻了工厂类的负担，把某一类/某一种东西交由一个工厂生产，同时增加某一类”东西“并不需要修改工厂类，只需要添加生产这类”东西“的工厂即可，使得工厂类符合开放-封闭原则。
对于”东西“的分类，有时候不能光是横向的分类，从另一个角度也是可以分类的，不知道这句话的意思能不能懂，打个比方：汽车可以根据品牌分为奔驰、奥迪，也可以根据类别分为普通三厢车和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.youkuaiyun.com/superbeck/article/details/4446177#comments

http://www.cnblogs.com/devinzhang/archive/2011/12/19/2293160.html