简单工厂模式（Simple Factory）

首先定义一个产品类的共同接口

public interface Product{//价格int price();//产品名String getName();}

分别有三个产品ProductA、ProductB、ProductC ，均实现Product接口

ProductA

public class ProductA implements Product {@Overridepublic int price() {return 100;}@Overridepublic String getName() {return "ProductA";}}

ProductB

public class ProductB implements Product {@Overridepublic int price() {return 200;}@Overridepublic String getName() {return "ProductB";}}

ProductC

public class ProductC implements Product {@Overridepublic int price() {return 300;}@Overridepublic String getName() {return "ProductC";}}

定义一个生产工厂类，根据输入类型生产对应的产品

public class Factory {/*** 根据生产类型生产对应的产品* @param type* @return*/public static Product createProduct(String type){Product product =null;switch (type){case "A":product = new ProductA();break;case "B":product = new ProductB();break;case "C":product = new ProductC();break;}return product;}}

根据输入的生产类型生产对应的产品

Product productA = Factory.createProduct("A");System.out.println("productA name="+productA.getName()+",getPrice:"+productA.getPrice());Product productB = Factory.createProduct("B");System.out.println("productB name="+productB.getName()+",getPrice:"+productB.getPrice());Product productC = Factory.createProduct("C");System.out.println("productC name="+productC.getName()+",getPrice:"+productC.getPrice());

输出结果：

productA name=ProductA,getPrice:100
productB name=ProductB,getPrice:200
productC name=ProductC,getPrice:300

以上便是简单工厂模式的一个典型事例，当用户需要新增产品ProductD时，必须在工厂类的生产方法中增加对应的判断分支，所以简单工厂模式违背了开放封闭原则。

简单工厂模式，利用静态方法根据输入参数生成对应的产品，隐藏了产品实例化的细节。

总结：简单工厂模式最大的优点在于工厂类中包含了必要的逻辑判断，根据客户端的选择条件动态实例化相关的类，对于客户端来说，去除了与具体产品的依赖。但是当需求变动的时候，需要对原有的类进行修改，违背了开放封闭原则。

工厂方法模式（Factory Method）

通过工厂方法模式，可以解决简单工厂模式的问题。

首先声明一个工厂接口，所有工厂必须实现这个接口

public interface IFactory {Product createProduct();}

生产ProductA的工厂FactoryA

public class FactoryA implements IFactory {@Overridepublic Product createProduct() {return new ProductA();}}

生产ProductB的工厂FactoryB

public class FactoryB implements IFactory {@Overridepublic Product createProduct() {return new ProductB();}}

同样地，生产ProductC的工厂FactoryC跟以上模式一样。

现在来根据新的工厂方法模式来生产

IFactory factoryA = new FactoryA();Product productA = factoryA.createProduct();System.out.println("productA name="+productA.getName()+",getPrice:"+productA.getPrice());IFactory factoryB = new FactoryB();Product productB = factoryB.createProduct();System.out.println("productB name="+productB.getName()+",getPrice:"+productB.getPrice());IFactory factoryC = new FactoryB();Product productC = factoryC.createProduct();System.out.println("productC name="+productC.getName()+",getPrice:"+productC.getPrice());

输出结果：

productA name=ProductA,getPrice:100
productB name=ProductB,getPrice:200
productC name=ProductC,getPrice:300

当需要增加一个新产品ProductD,只需要新建对应的FactoryD来实现生产功能即可,对原有的代码没有任何影响，非常符合开放封闭原则，但是由于每增加一个产品，都需要新增对应的生产工厂，导致增加额外的开发工作量。

总结：由于使用了多态，工厂方法克服了简单工厂违背的开放封闭原则的缺点，又保持了封装对象创建过程的优点。

抽象工厂模式 (Abstract Factory)

假设现在需要针对每种产品生产对应的赠品，难道我们要新增一个Gift的生产工厂吗？其实没有必要，因为在这个场景下，每种产品必须附带了赠品，所以我们可以利用原有的工厂来生产赠品。

先定一个共同的Gift接口

public interface Gift {String getGiftName();}

增加GiftA、GiftB、GiftC

public class GiftA implements Gift {@Overridepublic String getGiftName() {return "GiftA";}}

修改Factory接口，增加生产Gift的方法

public interface IFactory {Product createProduct();Gift createGift();}

修改工厂方法模式下的FactoryA、FactoryB、FactoryC

public class FactoryA implements IFactory {@Overridepublic Gift createGift() {return new GiftA();}@Overridepublic Product createProduct() {return new ProductA();}}

生产产品和赠品

IFactory factoryA = new FactoryA();Product productA = factoryA.createProduct();Gift giftA = factoryA.createGift();

总结：抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无需制定他们具体的类。抽象工厂接口，应该包含所有的产品创建的抽象方法，我们可以定义实现不止一个接口，一个工厂也可以生产不止一种产品类，和工厂方法模式一样，抽象工厂模式同样实现了开发封闭原则
原文链接：/p/d27d698802fd