设计模式之工厂方法模式(5):稍微复杂一点的工厂模式

场景

我们创建商品:苹果、橙子、每一个苹果橙子里面的都有相同的逻辑

内容

1.使用简单工厂模式

image.png

  1. 每一类商品都创建自己的工厂
  2. 每一类商品里面都封装:创建商品通用的逻辑和差异逻辑
  3. excute里面封装了通用和差异的逻辑
public class NonPattern {
    public static void main(String[] args) {
        //1.创建苹果
        Product product1 = AppleProductFactory.create();
        product1.excute();
         //产品预处理:通用逻辑
        //产品:苹果

        //2.创建橙子
        Product product2 = OrangeProductFactory.create();
        product2.excute(); 
        //产品预处理:通用逻辑
        //产品:橙子
    }



    public interface Product{
        void excute();
    }

    public static class AppleProduct implements Product{
        private String name = "苹果";
        public void excute() {
            System.out.println("产品预处理:通用逻辑");
            System.out.println("产品:"+this.name);
        }
    }

    public static class OrangeProduct implements Product{
         private String name = "橙子";

         public void excute() {
             System.out.println("产品预处理:通用逻辑");
             System.out.println("产品:"+this.name);
         }
    }

    public static class AppleProductFactory{
      public static Product create(){
          return new AppleProduct();
      };
    }

    public static class OrangeProductFactory{
        public static   Product create(){
            return new OrangeProduct();
        };
    }
}

2.使用工厂模板模式

2.1 类图

image.png

2.2 代码

public class FactoryMethodPattern2 {
    public static void main(String[] args) {
        //1.创建苹果
        Product apple = AppleProductFactory.getInstance().create();
        apple.excute();
        /**
         * 输出:
         * 产品预处理:通用逻辑
         * 产品:苹果
         */

        //2.创建橙子
        Product orange = OrangeProductFactory.getInstance().create();
        orange.excute();
        /**
         * 输出:
         * 产品预处理:通用逻辑
         * 产品:橙子
         */
    }

//================================工厂============================
    public static abstract class AbstractProductFactory{
        public Product create(){
            commonExcute();
            return specialExcute();
        }

        public void commonExcute(){
            System.out.println("产品预处理:通用逻辑");
        }
        public abstract Product specialExcute();
    }

    public static class AppleProductFactory extends AbstractProductFactory{
        private static final AppleProductFactory instance = new AppleProductFactory();

        public static AppleProductFactory getInstance(){
            return instance;
        }
        public Product specialExcute() {
            return new AppleProduct();
        }
    }

    public static class OrangeProductFactory extends AbstractProductFactory{
        private static final OrangeProductFactory instance = new OrangeProductFactory();

        public static OrangeProductFactory getInstance(){
            return instance;
        }

        public Product specialExcute() {
            return new OrangeProduct();
        }
    }

//================================类============================
    public interface Product{
        void excute();
    }

    public static class AppleProduct implements Product{
        private String name = "苹果";
        public void excute() {
            System.out.println("产品:"+this.name);
        }
    }

    public static class OrangeProduct implements Product{
         private String name = "橙子";

         public void excute() {
             System.out.println("产品:"+this.name);
         }
    }
}

3.总结

3.1 不使用设计模式对比

  1. 问题跟模板方法模式的问题一模一样;就是多个工厂类中,有生产产品的相同的通用逻辑,没有抽取出来,直接复制粘贴放多个工厂里了;如果那段通用逻辑要修改;就需要很麻烦到所有工厂中去修改代码;可能会忘记修改某个工厂的代码.

3.2 不使用设计模式对比

  1. 这种设计模式算是较为复杂一点的工厂模式了;适用的是比较复杂的场景了; 一般就是需要多种工厂生产不同的产品, 但是产品都是类似的,同时不同的工厂有一定的相同逻辑; 那么就用这种模式。

评论

暂无评论