工厂方法模式

定义创建对象的接口（或抽象类），让实现这个接口的类来决定实例化哪个类，工厂方法让类的实例化推迟到子类进行。

分析实现步骤

类图
image.png

  1. 创建抽象类(不变)
  2. 创建地域特色的产品类
  3. 创建工厂方法
  4. 创建子类实现工厂方法
  5. 客户端测试
  6. 分析

代码实现

创建地域特色的产品类

  1. /**
  2.  * 中国奶油蛋糕
  3.  */
  4. public class CNCreamCake extends AbstractCake {
  5.     @Override
  6.     public void prepare() {
  7.         System.out.println("原料：原胚、奶油、中国元素");
  8.     }
  9. }
  1. /**
  2.  * 中国水果蛋糕
  3.  */
  4. public class CNfruitCake extends AbstractCake {
  5.     @Override
  6.     public void prepare() {
  7.         System.out.println("原料：原胚、水果、中国元素");
  8.     }
  9. }
  1. /**
  2.  * 美国奶油蛋糕
  3.  */
  4. public class USCreamCake extends AbstractCake {
  5.     @Override
  6.     public void prepare() {
  7.         System.out.println("原料：原胚、奶油、美国元素");
  8.     }
  9. }
  1. /**
  2.  * 美国水果蛋糕
  3.  */
  4. public class USfruitCake extends AbstractCake {
  5.     @Override
  6.     public void prepare() {
  7.         System.out.println("原料：原胚、水果、美国元素");
  8.     }
  9. }

创建工厂方法

  1. /**
  2.  * 工厂方法,有方法,但不实现,下放到子类去执行
  3.  */
  4. public abstract class FactoryMethod {
  6.     //定义一个抽象方法，让各个工厂子类自己实现
  7.     abstract AbstractCake createCake(String orderType);
  9.     public FactoryMethod() {
  10.         AbstractCake cake;
  11.         String orderType;
  12.         do {
  13.             orderType = getType();
  14.             //获取简单(静态)工厂
  15.             cake = createCake(orderType);
  16.             if(cake != null) {
  17.                 cake.prepare();
  18.                 cake.bake();
  19.                 cake.box();
  20.                 cake.send();
  21.             } else {
  22.                 System.out.println("预定失败");
  23.                 break;
  24.             }
  25.         }while(true);
  26.     }
  28.     //输入蛋糕类型
  29.     private String getType() {
  30.         try {
  31.             BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
  32.             System.out.println("请输入蛋糕类型：");
  33.             return strin.readLine();
  34.         } catch (IOException e) {
  35.             e.printStackTrace();
  36.             return "";
  37.         }
  38.     }
  39. }

创建子类实现工厂方法

  1. /**
  2.  * 子类实现（中国）工厂方法
  3.  */
  4. public class CNOrderCake extends FactoryMethod{
  5.     @Override
  6.     AbstractCake createCake(String orderType) {
  7.         AbstractCake cake = null;
  8.         if (orderType.equals("水果")) {
  9.             cake = new CNfruitCake();
  10.             cake.setName(orderType + "蛋糕(中国味道)");
  11.         } else if (orderType.equals("奶油")) {
  12.             cake = new CNCreamCake();
  13.             cake.setName(orderType + "蛋糕(中国味道)");
  14.         } else {
  15.             System.out.println("暂不支持的蛋糕类型");
  16.             return cake;
  17.         }
  18.         return cake;
  19.     }
  20. }
  1. /**
  2.  * 子类实现（美国）工厂方法
  3.  */
  4. public class USOrderCake extends FactoryMethod{
  5.     @Override
  6.     AbstractCake createCake(String orderType) {
  7.         AbstractCake cake = null;
  8.         if (orderType.equals("水果")) {
  9.             cake = new USfruitCake();
  10.             cake.setName(orderType + "蛋糕(美国味道)");
  11.         } else if (orderType.equals("奶油")) {
  12.             cake = new USCreamCake();
  13.             cake.setName(orderType + "蛋糕(美国味道)");
  14.         } else {
  15.             System.out.println("暂不支持的蛋糕类型");
  16.             return cake;
  17.         }
  18.         return cake;
  19.     }
  20. }

客户端测试

  1. public class CakeStore {
  3.     public static void main(String[] args) {
  4.         //中国
  5.         new CNOrderCake();
  6.         //美国
  7. //        new USOrderCake();
  8.     }
  9. }
  11. //测试结果
  12. 请输入蛋糕类型：
  13. 水果
  14. 原料：原胚、水果、中国元素
  15. 水果蛋糕(中国味道)烘焙;
  16. 水果蛋糕(中国味道)包装;
  17. 水果蛋糕(中国味道)配送;
  18. 请输入蛋糕类型：
  19. 巧克力
  20. 暂不支持的蛋糕类型
  21. 预定失败

分析
由上代码可知，此时如果新增一个英国口味的各种蛋糕，则继承通用工厂方法，新增一个定制的子类预定类的实现，以及新增对应的类型的蛋糕实现。确实有很好的OCP，但是有没有觉得很复杂，新建的类有点多，感觉还不如简单方法细化蛋糕类（TODO 可能境界没有达到，后面再体会一下）。

框架或项目源码分析


应用场景

  • 客户只知道创建产品的工厂名，而不知道具体的产品名
  • 创建对象的任务由多个具体子工厂中的某一个完成，而抽象工厂只提供创建产品的接口
  • 客户不关心创建产品的细节，只关心产品的品牌