分别有三个产品ProductA、ProductB、ProductC ，均实现Product接口
//ProductA public class ProductA implements Product { @Override public int price() { return 100; } @Override public String getName() { return "ProductA"; } } //ProductB public class ProductB implements Product { @Override public int price() { return 200; } @Override public String getName() { return "ProductB"; } } //ProductC public class ProductC implements Product { @Override public int price() { return 300; } @Override public 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时，必须在工厂类的生产方法中增加对应的判断分支，所以简单工厂模式违背了开放封闭原则。
简单工厂模式，利用静态方法根据输入参数生成对应的产品，隐藏了产品实例化的细节。
总结： 简单工厂模式最大的优点在于工厂类中包含了必要的逻辑判断，根据客户端的选择条件动态实例化相关的类，对于客户端来说，去除了与具体产品的依赖。但是当需求变动的时候，需要对原有的类进行修改，违背了开放封闭原则。
工厂设计模式，简单工厂设计模式、抽象工厂设计模式链接：https://www.jianshu.com/p/d27d698802fd
三、工厂设计模式
通过工厂方法模式，可以解决简单工厂模式的问题。
首先声明一个工厂接口，所有工厂必须实现这个接口
public interface IFactory { Product createProduct(); }
生产ProductA的工厂FactoryA public class FactoryA implements IFactory { @Override public Product createProduct() { return new ProductA(); } } 生产ProductB的工厂FactoryB public class FactoryB implements IFactory { @Override public 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来实现生产功能即可,对原有的代码没有任何影响，非常符合开放封闭原则，但是由于每增加一个产品，都需要新增对应的生产工厂，导致增加额外的开发工作量。
总结：由于使用了多态，工厂方法克服了简单工厂违背的开放封闭原则的缺点，又保持了封装对象创建过程的优点。
