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

场景

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

内容

1.使用简单工厂模式

每一类商品都创建自己的工厂
每一类商品里面都封装:创建商品通用的逻辑和差异逻辑

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 类图

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 不使用设计模式对比

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

3.2 不使用设计模式对比

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