场景： （1）我们现在要生产的产品有多种 （2）每种产品的生产过程，都有一些是共同的逻辑，但是也有一些是特殊的逻辑 （3）现在要生产出来各种产品

1.常规

  1. package com.example.demo.pattern.factory;
  3. /**
  4.  * @author chenchao
  5.  */
  6. public class WithoutFactoryMethodPatternDemo {
  8.     public static void main(String[] args) {
  9.         Product product1 = Product1Factory.createProduct();
  10.         Product product2 = Product2Factory.createProduct();
  11.         Product product3 = Product3Factory.createProduct();
  13.         product1.execute();
  14.         product2.execute();
  15.         product3.execute();
  17.         // 问题在哪儿？
  18.         // 跟模板方法模式的问题一模一样
  19.         // 就是多个工厂类中，有生产产品的相同的通用逻辑，没有抽取出来，直接复制粘贴放多个工厂里了
  20.         // 如果那段通用逻辑要修改
  21.         // 就需要很麻烦到所有工厂中去修改代码；可能会忘记修改某个工厂的代码
  22.     }
  24.     public interface Product {
  26.         void execute();
  28.     }
  30.     public static class Product1 implements Product {
  31.         @Override
  32.         public void execute() {
  33.             System.out.println("产品1的功能逻辑");
  34.         }
  36.     }
  38.     public static class Product2 implements Product {
  39.         @Override
  40.         public void execute() {
  41.             System.out.println("产品2的功能逻辑");
  42.         }
  44.     }
  46.     public static class Product3 implements Product {
  47.         @Override
  48.         public void execute() {
  49.             System.out.println("产品3的功能逻辑");
  50.         }
  52.     }
  54.     public static class Product1Factory {
  56.         public static Product createProduct() {
  57.             System.out.println("生产产品的通用逻辑，修改");
  58.             System.out.println("生产产品1的特殊逻辑");
  59.             return new Product1();
  60.         }
  62.     }
  64.     public static class Product2Factory {
  66.         public static Product createProduct() {
  67.             System.out.println("生产产品的通用逻辑，修改");
  68.             System.out.println("生产产品2的特殊逻辑");
  69.             return new Product2();
  70.         }
  72.     }
  74.     public static class Product3Factory {
  76.         public static Product createProduct() {
  77.             System.out.println("生产产品的通用逻辑");
  78.             System.out.println("生产产品3的特殊逻辑");
  79.             return new Product3();
  80.         }
  82.     }
  84. }

2.工厂方法模式

  1. package com.example.demo.pattern.factory;
  3. /**
  4.  * @author chenchao
  5.  * @date 2021/11/8
  6.  */
  7. public class FactoryMethodPatternDemo {
  9.     public static void main(String[] args) {
  10.         Product product1 = Product1Factory.get().createProduct();
  11.         Product product2 = Product2Factory.get().createProduct();
  12.         Product product3 = Product3Factory.get().createProduct();
  14.         product1.execute();
  15.         product2.execute();
  16.         product3.execute();
  17.     }
  19.     public interface Product {
  21.         void execute();
  23.     }
  25.     public static class Product1 implements Product {
  26.         @Override
  27.         public void execute() {
  28.             System.out.println("产品1的功能逻辑");
  29.         }
  31.     }
  33.     public static class Product2 implements Product {
  34.         @Override
  35.         public void execute() {
  36.             System.out.println("产品2的功能逻辑");
  37.         }
  39.     }
  41.     public static class Product3 implements Product {
  42.         @Override
  43.         public void execute() {
  44.             System.out.println("产品3的功能逻辑");
  45.         }
  47.     }
  49.     public static abstract class AbstractProductFactory {
  51.         public Product createProduct() {
  52.             commonCreate();
  53.             return specificCreate();
  54.         }
  56.         private void commonCreate() {
  57.             System.out.println("生产产品的通用逻辑，修改");
  58.         }
  60.         protected abstract Product specificCreate();
  62.     }
  64.     public static class Product1Factory extends AbstractProductFactory {
  66.         private static final Product1Factory instance = new Product1Factory();
  68.         private Product1Factory() {
  70.         }
  72.         public static Product1Factory get() {
  73.             return instance;
  74.         }
  76.         @Override
  77.         public Product specificCreate() {
  78.             System.out.println("生产产品1的特殊逻辑");
  79.             return new Product1();
  80.         }
  82.     }
  84.     public static class Product2Factory extends AbstractProductFactory {
  86.         private static final Product2Factory instance = new Product2Factory();
  88.         private Product2Factory() {
  90.         }
  92.         public static Product2Factory get() {
  93.             return instance;
  94.         }
  96.         @Override
  97.         public Product specificCreate() {
  98.             System.out.println("生产产品2的特殊逻辑");
  99.             return new Product2();
  100.         }
  102.     }
  104.     public static class Product3Factory extends AbstractProductFactory {
  106.         private static final Product3Factory instance = new Product3Factory();
  108.         private Product3Factory() {
  110.         }
  112.         public static Product3Factory get() {
  113.             return instance;
  114.         }
  116.         @Override
  117.         public Product specificCreate() {
  118.             System.out.println("生产产品3的特殊逻辑");
  119.             return new Product3();
  120.         }
  122.     }
  124. }

3.说明

说实话，这种设计模式算是较为复杂一点的了，适用的是比较复杂的场景了
一般就是在有复杂工厂生产场景的情况下，比如就是需要多种工厂生产不同的产品，但是产品都是类似的，同时不同的工厂有一定的相同逻辑，那么就用这种模式