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

场景：

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

1、不使用工厂方法模式

/**
 * 不使用设计模式
 */
public class WithoutFactoryMethodPatternDemo {
    /**
     * 问题在哪儿？
     * 跟模板方法模式的问题一样
     * 就是多个工厂类中，有生产产品的相同的通用逻辑，没有抽取出来，
     * 直接复制粘贴放在多个工厂里了
     * 如果那段通用逻辑要修改
     * 就需要很麻烦到所有工厂中去修改代码，可能会忘记修改了某个工厂的代码
     */
    public static void main(String[] args) {

        Product product1 = Product1Factory.creatProduct();
        product1.execute();

        Product product2 = Product2Factory.creatProduct();
        product2.execute();

        Product product3 = Product3Factory.creatProduct();
        product3.execute();
    }

       // 产品接口类
    public interface Product{
        void execute();
    }
       // 产品接口实现类1
    public static class Product1 implements Product{
        @Override
        public void execute() {
            System.out.println("产品1的功能逻辑");
        }
    }
       // 产品接口实现类2
    public static class Product2 implements Product{
        @Override
        public void execute() {
            System.out.println("产品2的功能逻辑");
        }
    }
       // 产品接口实现类3
    public static class Product3 implements Product{
        @Override
        public void execute() {
            System.out.println("产品2的功能逻辑");
        }
    }
       // 工厂类1
    public static class Product1Factory{
        public static Product createProduct(){
            System.out.println("生产产品的通用逻辑");
            System.out.println("生产产品1的特殊逻辑");
            return new Product1();
        }
    }
       // 工厂类2
    public static class Product2Factory{
        public static Product createProduct(){
            System.out.println("生产产品的通用逻辑");
            System.out.println("生产产品 2 的特殊逻辑");
            return new Product2();
        }
    }
       //工厂类3
    public static class Product3Factory{
        public static Product createProduct(){
            System.out.println("生产产品的通用逻辑");
            System.out.println("生产产品 3 的特殊逻辑");
            return new Product3();
        }
    }
}

2、使用工厂方法模式

/**
 * 使用工厂方法设计模式
 */
public class FactoryMethodPatternDemo {

       // 主函数
    public static void main(String[] args) {
        Product product1 = Product1Factory.get().createProduct();
        Product product2 = Product2Factory.get().createProduct();
        Product product3 = Product3Factory.get().createProduct();
    }

        // 产品接口
    public interface Product{
        void execute();
    }

       // 产品接口实现类1
    public static class Product1 implements Product {
        @Override
        public void execute() {
            System.out.println("产品1的功能逻辑");
        }
    }

       // 产品接口实现类2
    public static class Product2 implements Product {
        @Override
        public void execute() {
            System.out.println("产品2的功能逻辑");
        }
    }

       // 产品接口实现类3
    public static class Product3 implements Product {
        @Override
        public void execute() {
            System.out.println("产品2的功能逻辑");
        }
    }

    // 抽象工厂
    public static abstract class AbstractProductFactory{

        public Product createProduct(){
            commonCreate();
            return specificCreate();
        }

        private void commonCreate() {
            System.out.println("生厂产品通用的步骤");
        }

        protected abstract Product specificCreate();
    }

        // 抽象工厂子类1
    public static class Product1Factory extends AbstractProductFactory{

        private static Product1Factory instance =new Product1Factory();

        private Product1Factory() {
           }

        public static Product1Factory get(){
            return instance;
           }

        @Override
        protected Product specificCreate() {
            System.out.println("生产产品1的特殊逻辑");
            return new Product1();
          }
    }

        // 抽象工厂子类2
    public static class Product2Factory extends AbstractProductFactory{

        private static Product2Factory instance =new Product2Factory();

        private Product2Factory() {
        }

        public static Product2Factory get(){
            return instance;
        }

        @Override
        protected Product specificCreate() {
            System.out.println("生产产品 2 的特殊逻辑");
            return new Product2();
        }
    }

        // 抽象工厂子类3
    public static class Product3Factory extends AbstractProductFactory{

        private static Product3Factory instance =new Product3Factory();

        private Product3Factory() {
        }

        public static Product3Factory get(){
            return instance;
        }

        @Override
        protected Product specificCreate() {
            System.out.println("生产产品 3 的特殊逻辑");
            return new Product3();
        }
    }
}

# 总结

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