序
书上是三个模式——简单工厂模式、工厂模式、抽象工厂模式，一块说。对于昨天实在没有休息好的状态下，看到如此混乱的景象，确实有点受不了。好在后面一遍又一遍重复，总算是理解了。但是，既然是记笔记，也是给别人看，那么我觉得拆开来说或许更加明白。
1、背景
书上用pizza来打比方，其实还是挺爱吃，但是名字太绕口，而且也不熟悉。所以还是用饺子我觉得会更加亲切些——我最爱吃的。
现在我要开一家饺子馆，供应各种口味的饺子，三鲜馅，胡萝卜羊肉馅，西胡虾仁馅，芹菜牛肉馅，猪肉大葱馅，猪肉白菜馅——看来好吃的说起来都没完没了。
最开始的想法是，按照如下步骤建立饺子：
1）用饺子抽象类建立饺子对象实体。
2）包饺子。
3）煮饺子。
4）装盘，配酱油和醋。
5）上桌或打包外卖。
实现成的代码如下——为了不让很多的名词困扰，此处直接采用更加形式化的命名方法：
//产品类型
abstract class ProductBase
{
@Override
public String toString() {
return "productbase";
}
}
class Product1 extends ProductBase
{
@Override
public String toString() {
return "product1";
}
}
class Product2 extends ProductBase
{
@Override
public String toString() {
return "product2";
}
}
//商店
class Store
{
ProductBase product;
public void create(String product) {
if(product.equals("product1"))
this.product=new Product1();
else if(product.equals("product2"))
this.product=new Product2();
//后续的操作
//包饺子（）;
//煮饺子（）；
//装盘，配酱油和醋（）；
//上桌或打包（）；
}
}
上面的代码将创建饺子对象和对饺子的后续的加工操作，严重耦合，造成以下两个比较严重的问题：
1）一个函数中的代码量过大，而且随着新类型产品研发，这个函数将越来越大，不容易维护。
2）当餐馆发明新的饺子时，就需要修改sell()方法。原来类的封装性就遭到破坏。
2、简单工厂模式
根据上面的问题，我们自然想到的是将创建产品对象的那部分代码进行封装，这样就实现了工厂模式。简单工厂模式如下：
//产品类型
abstract class ProductBase
{
@Override
public String toString() {
return "productbase";
}
}
class Product1 extends ProductBase
{
@Override
public String toString() {
return "product1";
}
}
class Product2 extends ProductBase
{
@Override
public String toString() {
return "product2";
}
}
class ProductFactory
{
public ProductBase create(String product)
{
if(product.equals("product1"))
return new Product1();
else if(product.equals("product2"))
return new Product2();
else return null;
}
}
//商店
class Store
{
ProductBase product;
ProductFactory productFactory;
public Store(ProductFactory productFactory)
{
this.productFactory=productFactory;
}
public void create(String product) {
/* if(product.equals("product1"))
this.product=new Product1();
else if(product.equals("product2"))
this.product=new Product2();
*/
this.productFactory.create(product);
//后续的操作
//包饺子（）;
//煮饺子（）；
//装盘，配酱油和醋（）；
//上桌或打包（）；
}
}
“简单工厂模式”是将对象的生成和使用进行分离，以组合的方式，当创建使用某一类对象的实体时（如Store类的对象），将真正创建对象的工厂传入。从而获得以下两方面的收益：
1）工厂可以在动态运行时的时候指定。比如我现在不打算开饺子店了，想做包子，由于包子和饺子的后续工作都是一样的，所以只需把制作包子的工厂传入Store类中就行。
2）产品、制作、使用三者进行了有效分离。产品的分离已经在前面的策略模式中说道——用抽象接口来“临时”代替具体类，占位置，将创建对象实体推迟到运行时。制作即使用了简单工厂模式，而使用即为Store类。这样就在一定程度上，将类之间的耦合度降到很低。
3、工厂模式
相对于简单工厂模式，工厂模式的耦合度相对来说比较大。之所以比较大，先看下面的例子。
假设饺子店生意不错，规模逐渐增大，最后成立一个实业公司——饺子餐饮有限公司，而且设立了各个分部——华北子公司，东北子公司，华南子公司，华东子公司，中西部子公司。为了保证所有公司生产的饺子质量过关，公司决定控制生产流程。所有子公司可以根据当地特产，选择自己的馅料，但是制作工艺必须严格按照公司的流程，比如每个面皮必须为10g，直径5CM的圆面片。馅料必须20g。
这样，既增加了灵活性——子公司可以根据当地特产选择馅料，又保证了质量——严格按照母公司的规程办事。
说这么多，我想“简单工厂模式”和“工厂模式”应用的场景大家也应该能看出来了。
1）简单工厂模式是针对只有一个使用者的情况来说，即程序中只有一个Store类，这个Store类可以使用多用“工厂类”来为自己加工产品。
2）工厂模式不同，它是针对某个基类的一堆子类，在保证某些流程不改变的情况下， 允许子类有自己的行为特征。也就是说，基类规定了框架，而子类只能在框架的基础上修补、更改。
那么看下面的代码就比较能说明问题了：
abstract class ProductBase
{
@Override
public String toString() {
return "productbase";
}
}
class a1 extends ProductBase
{
@Override
public String toString() {
return "a1";
}
}
class a2 extends ProductBase
{
@Override
public String toString() {
return "a2";
}
}
class b1 extends ProductBase
{
@Override
public String toString() {
return "b1";
}
}
class b2 extends ProductBase
{
@Override
public String toString() {
return "b2";
}
}
//创建工厂基类
abstract class FactoryBase
{
public abstract ProductBase create(String type);
final public ProductBase sell(String type)
{
ProductBase productBase;
productBase=create(type);
//后续的操作
//包饺子（）;
//煮饺子（）；
//装盘，配酱油和醋（）；
//上桌或打包（）；
return productBase;
}
}
//实现工厂派生类
class Factory1 extends FactoryBase
{
@Override
public ProductBase create(String type) {
ProductBase productBase=null;
if(type.equals("a1"))
productBase=new a1();
else if(type.equals("a2"))
productBase=new a2();
return productBase;
}
}
class Factory2 extends FactoryBase
{
@Override
public ProductBase create(String type) {
ProductBase productBase=null;
if(type.equals("b1"))
productBase=new b1();
else if(type.equals("b2"))
productBase=new b2();
return productBase;
}
}
如上代码所示：
1）分别建立产品基类、工厂基类。由产品基类，根据不同地区（地区a和地区b），构建了子类产品。相应的，也构建了不同的子类工厂。
2）基类工厂中，sell()方法作为对外统一方法，控制生产总流程，因此生命为final方法。而create()方法则因地制宜，按照不同地区特点，生产特定的产品。
这样，工厂方法既保证了修改的灵活性，也保证了某些必要操作不会被修改。
