今天我们主要学习Java设计模式中的工厂方法模式，如果你看过我之前写的简单工厂模式会更容易理解下面的讲解，为了便于理解工厂方法模式我依然用食品加工厂为案例。

　　工厂方法模式去掉了简单工厂模式中工厂方法的静态属性，使得它可以被子类继承。这样在简单工厂模式里集中在工厂方法上的压力可以由工厂方法模式里不同　　的工厂子类来分担。

　　工厂方法模式使用继承自抽象工厂角色的多个子类来代替简单工厂模式中的“顶级类”。这样便分担了对象创建的压力；避免工厂类中用逻辑判断来决定创建对象，　　而且这样使得结构变得相当灵活当有新的产品产生时，只要按照抽象产品角色、抽象工厂角色提供的规则来生成，那么就可以被客户使用，而不必去修改任何已有的　　代码，可以看出工厂方法模式符合开闭原则。

  • AbstractProduct 类：抽象产品类，工厂方法模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口
  • Berr 类和 Drinks 类：具体产品类，是简单工厂模式的创建目标
  • AbstractFactory 类：抽象工厂类，这是工厂方法模式的核心，是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现
  • BerrFactory 类和 DrinksFactory 类：具体工厂类，它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象

　　这里我们以食品加工厂来举例，假设有一个食品加工厂，主要加工啤酒饮料矿泉水，根据需求，我们就需要用一个单独的类来专门生产啤酒饮料矿泉水，因为我　　们的工厂后期一定会做大做强，所以我们就要考虑这个设计方案对后续的业务拓展影响，我们厂子要求设计之初必须要在不影响现有业务基础上，能灵活拓展新的制　　造业务，根据食品加工厂的需求，我们采用了工厂方法设计模式。

　　第一步：设计我们产品也就是我们要生产的对象，按照结构我们设计代码如下

　　抽象产品类代码所有产品的父类，代码如下：

  1. package pattern.factory.product;
  2. /**
  3.  * 创建产品抽象类也可以用接口来定义
  4.  * @author ningbeibei
  5.  *
  6.  */
  7. public abstract class AbstractProduct {
  8.     //获取产品抽象方法，需要具体的实现类来实现
  9.     public abstract void getFood();
  10. }

　　 具体产品Berr（啤酒），代码如下：

  1. package pattern.factory.product;
  3. /**
  4.  * 啤酒具体啤酒类继承自AbstractProduct类
  5.  * @author ningbeibei
  6.  */
  7. public class Berr extends AbstractProduct {
  8.     @Override
  9.     public void getFood() {
  10.         System.out.println("啤酒");
  11.     };
  12. }

　　 具体产品Drinks （饮料），代码如下：

  1. package pattern.factory.product;
  3. /**
  4.  * 具体饮料类继承自AbstractProduct
  5.  * @author ningbeibei
  6.  */
  7. public class Drinks extends AbstractProduct {
  9.     @Override
  10.     public void getFood() {
  11.         System.out.println("饮料");
  12.     }
  13. }

　　第二步：设计制造产品的工厂，这也是工厂方法模式最总要的环节

　　创建工厂抽象类，代码如下：

  1. package pattern.factory.factorymill;
  2. import pattern.factory.product.AbstractProduct;
  3. /**
  4.  * 抽象工厂类,食品加工厂需要进行抽象设计
  5.  * @author ningbeibei
  6.  *
  7.  */
  8. public abstract class AbstractFactory {
  9.     //这个抽象方法返回一个产品对象，
  10.     public abstract AbstractProduct createProduct(); 
  11. }

　　创建具体啤酒制造工厂类BerrFactory，代码如下：

  1. package pattern.factory.factorymill;
  3. import pattern.factory.product.AbstractProduct;
  4. import pattern.factory.product.Berr;
  5. /**
  6.  * 专门知道啤酒的工厂，这个类实现自 AbstractFactory抽象类
  7.  * 返回一个啤酒产品对象
  8.  * @author ningbeibei
  9.  *
  10.  */
  11. public class BerrFactory extends AbstractFactory {
  12.     
  13.     //实现抽象工厂返回啤酒
  14.     @Override
  15.     public AbstractProduct createProduct() {
  16.         return new Berr();
  17.     }
  18. }

　　创建具体饮料制造工厂类，代码如下：

  1. package pattern.factory.factorymill;
  3. import pattern.factory.product.AbstractProduct;
  4. import pattern.factory.product.Drinks;
  6. /**
  7.  * 专门制造饮料工厂，继承自AbstractFactory抽象类
  8.  * @author ningbeibei
  9.  */
  10. public class DrinksFactory extends AbstractFactory {
  12.     //返回饮料对象
  13.     @Override
  14.     public AbstractProduct createProduct() {
  15.         return new Drinks();
  16.     }
  17. }

　　第三步：编写测试类进行测试验证

 

  1. package pattern.factory;
  3. import pattern.factory.factorymill.BerrFactory;
  4. import pattern.factory.factorymill.DrinksFactory;
  5. import pattern.factory.product.AbstractProduct;
  6. /**
  7.  * 工厂方法模式测试类
  8.  * @author ningbeibei
  9.  */
  10. public class test {
  12.     public static void main(String[] args) {
  13.         //先创建啤酒工厂
  14.         BerrFactory berrfactory = new BerrFactory();
  15.         //调用啤酒工厂中createProduct()方法，创建啤酒对象并返回
  16.         AbstractProduct product = berrfactory.createProduct();
  17.         //输出啤酒
  18.         product.getFood();
  19.         
  20.         //先创建饮料工厂
  21.         DrinksFactory drinksfactory = new DrinksFactory();
  22.         //调用饮料工厂中createProduct()方法，创建饮料对象并返回
  23.         AbstractProduct drinksproduct = drinksfactory.createProduct();
  24.         //输出饮料
  25.         drinksproduct.getFood();
  26.     }
  27. }

 

　　测试结果：

　　随着食品加工的规模扩张，我们食品加工厂想制造更多的产品，现在想制造矿泉水，根据设计之初的构想，不管后期业务扩展何种产品都不会动摇现有的代码，也就是不违背工厂模式的开闭原则。

　　1.新增产品矿泉水类并继承抽象产品类，代码如下：

  1. package pattern.factory.product;
  3. /**
  4.  * 新增矿泉水产品，同样继承自产品抽象类AbstractProduct
  5.  * @author ningbeibei
  6.  *
  7.  */
  8. public class Water extends AbstractProduct {
  10.     @Override
  11.     public void getFood() {
  12.         System.out.println("矿泉水");
  13.     }
  14. }

　　2.新增具体制造矿泉水工厂类并继承抽象类AbstractFactory，代码如下：

 

  1. package pattern.factory.factorymill;
  3. import pattern.factory.product.AbstractProduct;
  4. import pattern.factory.product.Water;
  5. /**
  6.  * 新增矿泉水制造工厂
  7.  * 继承自AbstractFactory抽象类
  8.  * @author ningbeibei
  9.  *
  10.  */
  11. public class WaterFactory extends AbstractFactory{
  13.     //制造矿泉水对象并返回
  14.     @Override
  15.     public AbstractProduct createProduct() {
  16.         return new Water();
  17.     }
  18. }

 

　　3.测试类编写，代码如下：

  1. package pattern.factory;
  3. import pattern.factory.factorymill.BerrFactory;
  4. import pattern.factory.factorymill.DrinksFactory;
  5. import pattern.factory.factorymill.WaterFactory;
  6. import pattern.factory.product.AbstractProduct;
  7. /**
  8.  * 工厂方法模式测试类
  9.  * @author ningbeibei
  10.  */
  11. public class test {
  13.     public static void main(String[] args) {
  14.         //先创建啤酒工厂
  15.         BerrFactory berrfactory = new BerrFactory();
  16.         //调用啤酒工厂中createProduct()方法，创建啤酒对象并返回
  17.         AbstractProduct product = berrfactory.createProduct();
  18.         //输出啤酒
  19.         product.getFood();
  20.         
  21.         //先创建饮料工厂
  22.         DrinksFactory drinksfactory = new DrinksFactory();
  23.         //调用饮料工厂中createProduct()方法，创建饮料对象并返回
  24.         AbstractProduct drinksproduct = drinksfactory.createProduct();
  25.         //输出饮料
  26.         drinksproduct.getFood();
  27.         
  28.         //这个是新增产品矿泉水
  29.         WaterFactory waterfactory = new WaterFactory();
  30.         //调用矿泉水工厂中createProduct()方法，创建矿泉水对象并返回
  31.         AbstractProduct waterproduct = waterfactory.createProduct();
  32.         //输出矿泉水
  33.         waterproduct.getFood();
  34.     }
  35. }

　　4.测试结果：

 

 

 　缺点：

  • 类的个数容易过多，增加复杂度
  • 增加了系统的抽象性和理解难度
  • 抽象产品只能生产一种产品，此弊端可使用抽象工厂模式解决　　

　优点：

  • 用户只需要知道具体工厂的名称就可得到所要的产品，无须知道产品的具体创建过程
  • 灵活性增强，对于新产品的创建，只需多写一个相应的工厂类
  • 典型的解耦框架。高层模块只需要知道产品的抽象类，无须关心其他实现类，满足迪米特法则、依赖倒置原则和里氏替换原则

 

　　先简单工厂模式===》而后工厂方法模式====》最后抽象工厂模式

　　由浅入深的学习在才能理解的更深更全面而后方能融会贯通

　　写的不足之处望批评指正，我一定改

 

版权声明：本文为ningbeibei原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/ningbeibei/p/14180451.html