factory method 模式：模板方法模式+简单工厂模式，简单工厂模式稍微复杂一点的变种；

    场景：

    • 我们现在要生产的产品有很多种；
    • 每种产品的生产过程，都是一些共同的逻辑，但是也有一些是特殊的逻辑；
    • 现在要生产出来各种产品；

    一般就是在有复杂工厂生产场景的情况下，比如就是需要多种工厂生产不同的产品，但是产品都是类似的，同时不同的工厂有一定的相同逻辑，那么就用这种模式 ；

    平时在项目中使用相对频率较低；
    image.png

    1. package com.example.designpattern.factory;
    3. public class FactoryMethodPatternDemo {
    4.     public static void main(String[] args) {
    5.         Product product1 = Product1Factory.get().createProduct();
    6.         Product product2 = Product2Factory.get().createProduct();
    7.         Product product3 = Product3Factory.get().createProduct();
    8.         product1.execute();
    9.         product2.execute();
    10.         product3.execute();
    12.     }
    13.     public interface Product {
    14.         void execute();
    15.     }
    16.     public static class Product1 implements Product {
    17.         public void execute() {
    18.             System.out.println("产品1的功能逻辑");
    19.         }
    20.     }
    21.     public static class Product2 implements Product {
    22.         public void execute() {
    23.             System.out.println("产品2的功能逻辑");
    24.         }
    25.     }
    26.     public static class Product3 implements Product {
    27.         public void execute() {
    28.             System.out.println("产品3的功能逻辑");
    29.         }
    30.     }
    31.     public static abstract class AbstractProductFactory{
    32.         public Product createProduct(){
    33.             commonCreate();
    34.             return specificCreate();
    35.         }
    36.         private void commonCreate(){
    37.             System.out.println("生产产品的通用逻辑...");
    38.         }
    39.         public abstract Product specificCreate();
    40.     }
    41.     public static class Product1Factory extends AbstractProductFactory{
    42.         public static final Product1Factory instance = new Product1Factory();
    44.         public static Product1Factory get(){
    45.             return instance;
    46.         }
    48.         public Product specificCreate() {
    49.             System.out.println("生产产品1的特殊逻辑");
    50.             return new Product1();
    51.         }
    52.     }
    53.     public static class Product2Factory extends AbstractProductFactory{
    54.         public static final Product2Factory instance = new Product2Factory();
    56.         public static Product2Factory get(){
    57.             return instance;
    58.         }
    59.         public Product specificCreate() {
    60.             System.out.println("生产产品2的特殊逻辑");
    61.             return new Product2();
    62.         }
    63.     }
    64.     public static class Product3Factory extends AbstractProductFactory{
    65.         public static final Product3Factory instance = new Product3Factory();
    67.         public static Product3Factory get(){
    68.             return instance;
    69.         }
    70.         public Product specificCreate() {
    71.             System.out.println("生产产品3的特殊逻辑");
    72.             return new Product3();
    73.         }
    74.     }
    75. }