场景优化-工厂模式和策略模式（非常实用且常用的设计模式）

最新推荐文章于 2024-08-14 10:00:00 发布
最新推荐文章于 2024-08-14 10:00:00 发布
阅读量1.1k 收藏 4
点赞数
分类专栏： 设计模式 文章标签： 设计模式 策略模式 工厂模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gghh2015/article/details/94880230
版权

先说一下总结：
工厂+策略并没有完全解决问题，而改进的策略模式才真正的带来便利。
如果把判断方式抽象成一个方法，在每一个策略的实现类中，就可以不用工厂模式了。
而且，每次修改都不用改判断逻辑部分，每添加一种策略，就在策略内实现判断，判断通过的返回策略对象。

问题：
随着业务代码的复杂度增加，我们的代码中出现了大量的 if-else，一坨一坨的，类也特别大，非常难看，而且还伴随着大量的重复代码，特别容易隐藏坑，比如增加或修改场景时，需要把所有重复的代码都改一遍，如果有遗漏就会产生bug。

目的：
所以要拆解类，要对重复代码抽象。

如何实现：
使用工厂模式、策略模式、工厂+策略模式对代码拆解。

工厂模式：
随场景不断优化，

  1. 简单场景使用 if-else 即可解决问题（V0版本）；
  2. 如果代码复杂可以使用封装把类拆开（V1版本）；
  3. 如果场景可能发生变化，频繁改动运行良好的代码不好，代码使用继承，使增加或修改尽可能的少影响线上运行代码，即工厂模式（V2版本）。
package com.designMode.factory.V0;

import java.io.BufferedReader;
import java.io.InputStreamReader;

/**
 * 如何实现一个计算器控制台程序，这是最简单直接的方法
 *
 * 分析：
 * 1、变量命名不规范 A B C
 * 2、对除法/的分子没有判断0
 *
 * 0、最严重的是思路问题，完全没有发挥面向对象的特征，封装，继承，多态
 *
 * 该怎么做：
 * 1、编程的原则，用尽可能的办法避免重复
 * 2、把功能分开，此处是控制台相关的，和计算相关的，请看V1版本
 *
 * @author zhangna12
 * @date 2019-07-06
 */
public class Calculator {
    public static void main(String[] args) {
        try{
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("请输入数字A:");
            String A = br.readLine();
            System.out.println("请输入数字B:");
            String B = br.readLine();
            System.out.println("请输入运算符号（+ - * /）：");
            String C = br.readLine();
            String D = "";

            if("+".equals(C)){
                D = String.valueOf(Double.parseDouble(A) + Double.parseDouble(B));
            }else if("-".equals(C)){
                D = String.valueOf(Double.parseDouble(A) - Double.parseDouble(B));
            }else if("*".equals(C)){
                D = String.valueOf(Double.parseDouble(A) * Double.parseDouble(B));
            }else if("/".equals(C)){
                if(Double.parseDouble(B) == 0){
                    System.out.println("除数不能为0");
                }else{
                    D = String.valueOf(Double.parseDouble(A) / Double.parseDouble(B));
                }
            }

            System.out.println("A=" + A + ",B=" + B + ",符号：" + C + ",结果：" + D );
        }catch (Exception e){
            System.out.println("未知异常");
        }
    }
}


package com.designMode.factory.V1;

import java.io.BufferedReader;
import java.io.InputStreamReader;

/**
 * 面向对象的思想，封装
 *
 * 分析：
 * 1、每要增加一种计算规则，就会使原来运行良好的代码产生变化，风险太大
 *
 * 改进：
 * 1、把每种计算规则分开，增加、修改不会影响其他，请看V2
 *
 * @author zhangna12
 * @date 2019-07-06
 */
public class Calculator {
    public static void main(String[] args) {
        try{
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("请输入数字A:");
            String A = br.readLine();
            System.out.println("请输入数字B:");
            String B = br.readLine();
            System.out.println("请输入运算符号（+ - * /）：");
            String C = br.readLine();
            String D = "";

            D = String.valueOf(Operation.getResult(Double.parseDouble(A),Double.parseDouble(B),C));

            System.out.println("A=" + A + ",B=" + B + ",符号：" + C + ",结果：" + D );
        }catch (Exception e){
            System.out.println("未知异常");
        }
    }
}



package com.designMode.factory.V1;

/**
 * 封装-计算相关的类
 *
 * @author zhangna12
 * @date 2019-07-06
 */
public class Operation {
    public static double getResult(double numA, double numB, String operate){
        double result = 0d;
        switch (operate){
            case "+":
                result = numA + numB;
                break;
            case "-":
                result = numA + numB;
                break;
            case "*":
                result = numA * numB;
                break;
            case "/":
                if(numB == 0){
                    System.out.println("除数不能为0");
                }else {
                    result = numA / numB;
                }
                break;
        }
        return result;
    }
}

package com.designMode.factory.V2;

import java.io.BufferedReader;
import java.io.InputStreamReader;

/**
 * 简单工厂模式
 * 面向对象的思想，封装、继承
 *
 * @author zhangna12
 * @date 2019-07-06
 */
public class Calculator {
    public static void main(String[] args) {
        try{
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("请输入数字A:");
            String A = br.readLine();
            System.out.println("请输入数字B:");
            String B = br.readLine();
            System.out.println("请输入运算符号（+ - * /）：");
            String C = br.readLine();
            String D = "";

            Operation operation = OperationFactory.createOperation(C);
            operation.setNumA(Double.parseDouble(A));
            operation.setNumB(Double.parseDouble(B));
            D = String.valueOf(operation.getResult());

            System.out.println("A=" + A + ",B=" + B + ",符号：" + C + ",结果：" + D );
        }catch (Exception e){
            System.out.println("未知异常");
        }
    }
}

package com.designMode.factory.V2;

/**
 * 请填写类的描述
 *
 * @author zhangna12
 * @date 2019-07-06
 */
public class OperationFactory {
    public static Operation createOperation(String operate){
        Operation operation = null;
        switch (operate){
            case "+":
                operation = new OperationAdd();
                break;
            case "-":
                operation = new OperationSub();
                break;
            case "*":
                operation = null;
                break;
            case "/":
                operation = null;
                break;
        }
        return operation;
    }
}


package com.designMode.factory.V2;

/**
 * 继承-分离计算规则
 *
 * @author zhangna12
 * @date 2019-07-06
 */
public abstract class Operation {

    private Double numA;
    private Double numB;

    public abstract double getResult();

    public Double getNumA() {
        return numA;
    }

    public void setNumA(Double numA) {
        this.numA = numA;
    }

    public Double getNumB() {
        return numB;
    }

    public void setNumB(Double numB) {
        this.numB = numB;
    }
}

package com.designMode.factory.V2;

/**
 * 请填写类的描述
 *
 * @author zhangna12
 * @date 2019-07-06
 */
public class OperationAdd extends Operation {
    @Override
    public double getResult() {
        return getNumA() + getNumB();
    }
}

package com.designMode.factory.V2;

/**
 * 请填写类的描述
 *
 * @author zhangna12
 * @date 2019-07-06
 */
public class OperationSub extends Operation {
    @Override
    public double getResult() {
        return getNumA() - getNumB();
    }
}

策略模式：
随场景不断优化，

  1. 基本场景（V0版本）
  2. 增加场景，使用 switch 判断（V1版本）
  3. 当增加的场景比较多，使用工厂模式（V2版本）
  4. 如果场景变化的又多又频繁，需要频繁的改动工厂类不好，使用策略模式（V3版本）
  5. 如何才能在频繁的改动下，最小的改动线上代码，且易维护，使用工厂+策略模式（V4版本，其实并没有解决问题）
  6. V5版本，参考 https://mp.weixin.qq.com/s/XQDZ9M0qLBz0xo-7O6t2oA 中策略模式的实现（懒得写了，自己看吧）。
package com.designMode.strategy.V0;

/**
 * 场景:
 * 商场收银软件，输入物品单价和数量，点击ok输出商品清单和总计
 *
 * 分析：
 * 1、如果场景变化，该怎么实现，请看V1
 *
 * @author zhangna12
 * @date 2019-07-06
 */
public class Shopping {

    static double total = 0d;

    private static void okClick(double price, double num){
        double totalPrice = price*num;
        total = total + totalPrice;
        System.out.println("单价：" + price + ",数量：" + num + ",合计：" + totalPrice + ",总计：" + total);
    }

    public static void main(String[] args) {
        okClick(12,2);
        okClick(1,3);
    }
}

package com.designMode.strategy.V1;

/**
 * 场景:
 * 商场收银软件，输入物品单价和数量，点击ok输出商品清单和总计
 * 增加场景：打8折，打7折，打5折
 *
 * 分析：
 * 1、每个打折的分支除了折扣力度不一样之外，其他都一样，可以考虑重构
 * 2、如果再增加返利的场景呢，满300-100，满500-200
 *
 * 改进：
 * 1、如果使用简单工厂，写一个父类，在继承实现多个打折和返利的子类，如果遇到场景叠加也要增加子类，比如打折的基础上再返利
 * 面向对象的编程，并不是类越多越好，类的划分是封装，但分类的基础是抽象，具有相同属性和功能的对象抽象集合才是类
 *
 * 2、按计算方式考虑，打折的算一类，返利算一类，请看V2
 *
 * @author zhangna12
 * @date 2019-07-06
 */
public class Shopping {

    static double total = 0d;

    private static void okClick(double price, double num, StrategyEnum se){

        double totalPrice = 0d;
        switch (se){
            case DIS_EIGHT:
                totalPrice = price*num*0.8;
                break;
            case DIS_FIVE:
                totalPrice = price*num*0.5;
                break;
        }
        total = total + totalPrice;
        System.out.println("单价：" + price + ",数量：" + num + ",合计：" + totalPrice + ",总计：" + total);
    }

    public static void main(String[] args) {
        okClick(12,2, StrategyEnum.DIS_FIVE);
        okClick(1,3, StrategyEnum.DIS_EIGHT);
    }
}

package com.designMode.strategy.V1;

/**
 * 请填写类的描述
 *
 * @author zhangna12
 * @date 2019-07-06
 */
public enum StrategyEnum {
    DIS_FIVE,
    DIS_EIGHT;

}

package com.designMode.strategy.V2;



/**
 * 场景:
 * 简单工厂实现
 * 商场收银软件，输入物品单价和数量，点击ok输出商品清单和总计
 * 增加场景：打8折，打7折，打5折，满300-100，满500-200
 *
 * 分析：
 * 1、比如商场的活动又频繁又多，每次增加或改动活动类型，都要去改动工厂方法，所以可以找更好的办法
 *
 * 改进：
 * 1、使用策略模式，请看V3
 *
 * @author zhangna12
 * @date 2019-07-06
 */
public class Shopping {

    static double total = 0d;

    private static void okClick(double price, double num, StrategyEnum se){

        double totalPrice = 0d;
        Cash cash = CashFactory.createCash(se);
        cash.getCash(price*num);
        total = total + totalPrice;
        System.out.println("单价：" + price + ",数量：" + num + ",合计：" + totalPrice + ",总计：" + total);
    }

    public static void main(String[] args) {
        okClick(12,2, StrategyEnum.RETURN_300_100);
        okClick(1,3, StrategyEnum.REBATE_EIGHT);
    }
}

package com.designMode.strategy.V2;

/**
 * 1、没有构造函数，直接返回策略对象
 *
 * @author zhangna12
 * @date 2019-07-06
 */
public class CashFactory {

    public static Cash createCash(StrategyEnum se){
        Cash cash = null;

        switch (se){
            case NORMAL:
                cash = new RebateCash(1);
                break;
            case REBATE_FIVE:
                cash = new RebateCash(0.5);
                break;
            case REBATE_EIGHT:
                cash = new RebateCash(0.8);
                break;
            case RETURN_300_100:
                cash = new ReturnCash(300,100);
                break;
            case RETURN_500_200:
                cash = new ReturnCash(500,200);
                break;
        }
        return cash;
    }
}

package com.designMode.strategy.V2;

/**
 * 请填写类的描述
 *
 * @author zhangna12
 * @date 2019-07-06
 */
public abstract class Cash {
    public abstract double getCash(double money);
}

package com.designMode.strategy.V2;

/**
 * 打折收费
 *
 * @author zhangna12
 * @date 2019-07-06
 */
public class RebateCash extends Cash {

    /**
     * 折扣率
     */
    private double moneyRebate = 1d;

    public RebateCash(double moneyRebate) {
        this.moneyRebate = moneyRebate;
    }

    @Override
    public double getCash(double money) {
        return money * moneyRebate;
    }
}

package com.designMode.strategy.V2;

/**
 * 满减
 *
 * @author zhangna12
 * @date 2019-07-06
 */
public class ReturnCash extends Cash {

    private double moneyCondition = 0.0d;
    private double moneyReturn = 0.0d;

    public ReturnCash(double moneyCondition, double moneyReturn) {
        this.moneyCondition = moneyCondition;
        this.moneyReturn = moneyReturn;
    }

    @Override
    public double getCash(double money) {
        double result = money;
        if(money > moneyCondition){
            result = money - Math.floor(money / moneyCondition) * moneyReturn;
        }
        return result;
    }
}

package com.designMode.strategy.V2;

/**
 * 请填写类的描述
 *
 * @author zhangna12
 * @date 2019-07-06
 */
public enum StrategyEnum {
    NORMAL,
    REBATE_FIVE,
    REBATE_EIGHT,
    RETURN_300_100,
    RETURN_500_200;
}


package com.designMode.strategy.V3;


/**
 * 场景:
 * 策略模式实现
 * 商场收银软件，输入物品单价和数量，点击ok输出商品清单和总计
 * 增加场景：打8折，打7折，打5折，满300-100，满500-200
 *
 * 分析：
 * 1、比如商场的活动又频繁又多，每次增加或改动活动类型，这个不用改CashContext了
 * 2、但是判断的过程不属于页面的操作
 *
 * 改进：
 * 1、使用工厂+策略模式，请看V4
 *
 * @author zhangna12
 * @date 2019-07-06
 */
public class Shopping {

    static double total = 0d;

    private static void okClick(double price, double num, StrategyEnum se){

        CashContext cashContext = null;

        switch (se){
            case NORMAL:
                cashContext = new CashContext(new RebateCash(1));
                break;
            case REBATE_FIVE:
                cashContext = new CashContext(new RebateCash(0.5));
                break;
            case REBATE_EIGHT:
                cashContext = new CashContext(new RebateCash(0.8));
                break;
            case RETURN_300_100:
                cashContext = new CashContext(new ReturnCash(300,100));
                break;
            case RETURN_500_200:
                cashContext = new CashContext(new ReturnCash(300,200));
                break;
        }

        double totalPrice = 0d;
        totalPrice = cashContext.getResult(price*num);
        total = total + totalPrice;
        System.out.println("单价：" + price + ",数量：" + num + ",合计：" + totalPrice + ",总计：" + total);
    }

    public static void main(String[] args) {
        okClick(12,2, StrategyEnum.RETURN_300_100);
        okClick(1,3, StrategyEnum.REBATE_EIGHT);
    }
}

package com.designMode.strategy.V3;

/**
 * 1、构造函数传入策略对象，方法返回计算结果
 *
 * @author zhangna12
 * @date 2019-07-06
 */
public class CashContext {

    private Cash cash;

    public CashContext(Cash cash) {
        this.cash = cash;
    }

    public double getResult(double money){
        return cash.getCash(money);
    }
}

package com.designMode.strategy.V3;

/**
 * 请填写类的描述
 *
 * @author zhangna12
 * @date 2019-07-06
 */
public abstract class Cash {
    public abstract double getCash(double money);
}

package com.designMode.strategy.V3;

/**
 * 打折收费
 *
 * @author zhangna12
 * @date 2019-07-06
 */
public class RebateCash extends Cash {

    /**
     * 折扣率
     */
    private double moneyRebate = 1d;

    public RebateCash(double moneyRebate) {
        this.moneyRebate = moneyRebate;
    }

    @Override
    public double getCash(double money) {
        return money * moneyRebate;
    }
}

package com.designMode.strategy.V3;

/**
 * 满减
 *
 * @author zhangna12
 * @date 2019-07-06
 */
public class ReturnCash extends Cash {

    private double moneyCondition = 0.0d;
    private double moneyReturn = 0.0d;

    public ReturnCash(double moneyCondition, double moneyReturn) {
        this.moneyCondition = moneyCondition;
        this.moneyReturn = moneyReturn;
    }

    @Override
    public double getCash(double money) {
        double result = money;
        if(money > moneyCondition){
            result = money - Math.floor(money / moneyCondition) * moneyReturn;
        }
        return result;
    }
}

package com.designMode.strategy.V3;

/**
 * 请填写类的描述
 *
 * @author zhangna12
 * @date 2019-07-06
 */
public enum StrategyEnum {
    NORMAL,
    REBATE_FIVE,
    REBATE_EIGHT,
    RETURN_300_100,
    RETURN_500_200;
}

package com.designMode.strategy.V4;


/**
 * 场景:
 * 工厂+策略模式实现
 * 商场收银软件，输入物品单价和数量，点击ok输出商品清单和总计
 * 增加场景：打8折，打7折，打5折，满300-100，满500-200
 *
 * 分析：
 * 1、比如商场的活动又频繁又多，每次增加或改动活动类型，这个不用改CashContext了
 * 2、但是判断的过程放到CashContext中
 *
 * 思考：
 * 这个工厂模式有啥区别，还不都是场景增加，修改判断的逻辑，只不过一个返回的是类，一个返回的是计算结果
 *
 * 改进：
 * 如果这个判断方式抽象成一个方法，在每一个策略的实现类中，就可以不用工厂模式了
 * 而且，每次修改都不用改判断逻辑部分，每添加一种策略，就在策略内实现判断，判断通过的返回
 * 详情见：https://mp.weixin.qq.com/s/XQDZ9M0qLBz0xo-7O6t2oA
 *
 * 综上：
 * 工厂+策略并没有完全解决问题，而是改进的策略模式才真正的带来便利
 *
 * @author zhangna12
 * @date 2019-07-06
 */
public class Shopping {

    static double total = 0d;

    private static void okClick(double price, double num, StrategyEnum se){

        CashContext cashContext = new CashContext(se);

        double totalPrice = 0d;
        totalPrice = cashContext.getResult(price*num);
        total = total + totalPrice;
        System.out.println("单价：" + price + ",数量：" + num + ",合计：" + totalPrice + ",总计：" + total);
    }

    public static void main(String[] args) {
        okClick(12,2, StrategyEnum.RETURN_300_100);
        okClick(1,3, StrategyEnum.REBATE_EIGHT);
    }
}

package com.designMode.strategy.V4;

/**
 * 1、使用构造函数获得策略对象
 * 2、构造函数中传入的是策略，不是策略对象
 * 3、返回计算结果
 *
 * @author zhangna12
 * @date 2019-07-06
 */
public class CashContext {

    private Cash cash;

    /**
     * 简单工厂的应用
     * @param se
     */
    public CashContext(StrategyEnum se) {
        switch (se){
            case NORMAL:
                cash = new RebateCash(1);
                break;
            case REBATE_FIVE:
                cash = new RebateCash(0.5);
                break;
            case REBATE_EIGHT:
                cash = new RebateCash(0.8);
                break;
            case RETURN_300_100:
                cash = new ReturnCash(300,100);
                break;
            case RETURN_500_200:
                cash = new ReturnCash(300,200);
                break;
        }
    }

    public double getResult(double money){
        return cash.getCash(money);
    }
}

package com.designMode.strategy.V4;

/**
 * 请填写类的描述
 *
 * @author zhangna12
 * @date 2019-07-06
 */
public abstract class Cash {
    public abstract double getCash(double money);
}


package com.designMode.strategy.V4;

/**
 * 打折收费
 *
 * @author zhangna12
 * @date 2019-07-06
 */
public class RebateCash extends Cash {

    /**
     * 折扣率
     */
    private double moneyRebate = 1d;

    public RebateCash(double moneyRebate) {
        this.moneyRebate = moneyRebate;
    }

    @Override
    public double getCash(double money) {
        return money * moneyRebate;
    }
}

package com.designMode.strategy.V4;

/**
 * 满减
 *
 * @author zhangna12
 * @date 2019-07-06
 */
public class ReturnCash extends Cash {

    private double moneyCondition = 0.0d;
    private double moneyReturn = 0.0d;

    public ReturnCash(double moneyCondition, double moneyReturn) {
        this.moneyCondition = moneyCondition;
        this.moneyReturn = moneyReturn;
    }

    @Override
    public double getCash(double money) {
        double result = money;
        if(money > moneyCondition){
            result = money - Math.floor(money / moneyCondition) * moneyReturn;
        }
        return result;
    }
}

package com.designMode.strategy.V4;

/**
 * 请填写类的描述
 *
 * @author zhangna12
 * @date 2019-07-06
 */
public enum StrategyEnum {
    NORMAL,
    REBATE_FIVE,
    REBATE_EIGHT,
    RETURN_300_100,
    RETURN_500_200;
}
gghh2015
关注
专栏目录
C#中的设计模式：实战中的重构与优化策略
java专栏
09-19 825
设计模式是一种解决特定问题的通用模板。它们不是代码，不是蓝图，也不是最终设计，而是解决问题的思想和方法。🧠在开始我们的重构之旅之前，让我们先来搞清楚什么是重构。重构（Refactoring）是改善现有代码的设计而不改变其外部行为的过程。简单来说，就是让代码变得更好，但保持它原来做的事情不变。🔧想象一下，在一个魔法世界里，我们需要一个能够控制魔法能量的中心枢纽。这个枢纽非常强大，但同时也非常危险，所以我们希望在整个王国中只存在一个这样的枢纽。这就是单例模式发挥作用的地方。
unity大场景优化
07-08
unity3d 大场景 优化 遮挡 LOD 适合做大型的场景学习研究
场景优化
pdw_jsp的专栏
12-30 728
前言：场景优化网上一大堆，然而东爷肯定不会去抄人家的，东爷是有节操的LOD 是什么鬼首先要说的是著名的LOD，什么是LOD自己百度，简单说下他的实现原理：LOD是根据相机的距离对远距离的物体使用低模，进出使用高模的方式，这样带来的好处就是既不减少表现效果又能减少面数。这时候你是不是在想这样很吊，然并卵，手机上对那些需要处理lod的物体的脚本开销我大概计算了下，都比面数来的直接。（这里并不是绝对的，主
工厂模式和策略模式
最新发布
m0_73381672的博客
08-14 1377
相较于简单工厂模式，不再是只有单一的一个工厂，而是一种汽车对应一个工厂，一个工厂专门只负责一种汽车的生产。优点是后续增加新的汽车种类，只需要新增一个汽车类和对应的汽车工厂类。可以看出，根据传入的不同的类型，得到不同的策略类，执行的也是不同的代码。缺点就是代码中有大量的ifelse，后续若是新增一个汽车，就需要对这个工厂类进行修改，这显然不符合设计模式的开闭原则。工厂模式加策略模式是一种在软件开发中常用的设计模式组合，它结合了工厂模式的创建型特点和策略模式的行为型特点，以提供更为灵活和可扩展的系统设计。
设计模式<面向对象的常用七大设计原则>
Gpwner的博客
02-28 1175
面向对象设计的目标之一在于支持可维护性复用，一方面需要实现设计方案或者源码的重用，另一方面要确保系统能够易于扩展和修改，具有较好的灵活性。 常用的设计原则有七个原则：1.单一职责原则（single responsibility principle，SPR） 一个类只负责一个功能领域中的相应职责。（或者可以定义为：就一个类而言，只有一个原因能够引起它变换）。 单一职责原则是实现高内聚、低耦合的指导
【Unity】场景优化
qq_26916435的博客
01-30 895
一、LOD层级细节技术 此技术需要美工的配合，提供给程序多个不同三角面数的模型 　　在场景中新建一个空的游戏物体，并添加LOD Group组件，如下图所示： 　　并将美工提供的三种不同精度的模型按照精度的大小依次拖入到LOD0、LOD1、LOD2中，LOD0为最近处的精细模型，Culled为不显示。 　　此时，场景中渲染显示的模型会根据相机与模型的距离进行切换显示，具体的切换显示距离可拖动...
工厂模式 + 策略模式优化if-else代码
qq_45433217的博客
10-16 170
工厂模式 + 策略模式一、创建奖金接口二、编写接口实现(策略模式)三、创建奖金工厂类(工厂模式)四、奖金使用方案Service类五、测试 看了一篇设计模式文章后，做个笔记表示曾经努力过。 先放个平时冗余的写法： public String getBonusPlan(Integer bonus) { if (bonus.equals(100)) { return "吃呷哺火锅"; } else if (bonus.equals(300)) { return "吃蜀大侠火
Apex-Utilities:通用Apex实用程序和设计模式
05-06
此书深入探讨了如何利用Apex提升开发效率，同时介绍了通用的实用工具和设计模式，以帮助开发者在Salesforce生态系统中更好地实现功能和优化代码。 1. **Apex基础知识**：首先，理解Apex的基础至关重要。这包括了解...
浅析.net策略模式
10-25
### 浅析.NET策略模式 #### 一、策略模式简介 策略模式是一种行为设计模式，它使你能在运行时改变对象的行为。...在实际开发中，结合其他设计模式（如工厂模式）可以进一步优化策略模式的实现，使其更加高效和简洁。
JAVA设计模式.chm
03-04
在实际开发中，我们还需要结合其他设计模式，如单例模式、建造者模式、策略模式等，以适应不同场景的需求。这些模式共同构成了Java软件设计的基石，帮助我们构建更加健壮、灵活和可扩展的系统。 总结来说，“JAVA...
深入浅出设计模式(中文版)
12-06
行为型设计模式则关注对象间的交互和责任分配，如观察者模式、策略模式、模板方法模式、命令模式、迭代器模式、职责链模式、备忘录模式、状态模式、访问者模式和解释器模式，这些模式能够使代码更加模块化，提高代码...
使用工厂模式+策略模式来优化代码结构
AnNanDu的博客
09-17 304
1. 业务场景 我们在新做的项目中有一个这样的应用场景，用户会导入不同平台的数据来存入mongodb中，不同平台的数据格式不一样，使用传统的mongoDB Model的方式需要建立太多的model，在后期维护上新加一个平台就需要增加一个model类重新上线一次，在可用性上不太合适，于是我考虑到工厂模式+策略模式来优化代码结构 2. 流程图 3. 代码 service interface service impl Strategy ...
策略模式+简单工厂-实际应用场景
01-11 2018
1、抽象策略接口 //抽象出他们共有的行为（支付行为） //从调用微信、支付宝、银联卡可以抽出一个公共的策略接口，同时也是为了实现定义中的互换 public interface PayStrategy { public void pay(float money); } 2、实现具体的策略 //支付宝支付的行为具体实现 public class AliPayStrategy im...
通过具体业务场景学习工厂模式与策略模式
qq_40126996的博客
02-05 178
入职新公司后熟悉业务过程中收到一个需求，优化一部分代码逻辑，优化时考虑业务的复杂性于是就想到使用设计模式优化这部分逻辑，将原来强耦合的逻辑拆分，便于以后的维护，分析之后确定使用工厂模式与策略模式。 先说下具体业务逻辑：首先业务逻辑中对象分为三个维度，分别为单票、大包、批次，每个维度需要执行不同的逻辑，执行逻辑就需要不同的策略来判断；这里策略有两种情况，分别为首次和重算，最后执行的逻辑则是请求其它服务的具体实现。 基于这种场景，首先考虑就是对于维度的拆分，单票、大包、批次都有不同的枚举状态来判断，..
代码重构：用工厂+策略模式优化过多的if else代码块
lppl010_的专栏
07-11 241
https://www.cnblogs.com/pfblog/p/7815238.html 最近在工作中优化了一段冗余的if else代码块，感觉对设计模式的理解和运用很有帮助，所以分享出来。鉴于原代码会涉及到公司的隐私，因此就不贴出来了。下面以更加通俗易懂的案例来解析。 假如写一个针对员工上班不遵守制度做相应惩罚的程序，比如，上班迟到：罚100；上班睡觉：罚1000；上班早退：警告；上...
使用工厂 + 策略模式优化if-else
人生就像一场戏
08-26 257
什么是策略模式？ 策略模式属于对象的行为模式。其用意是针对一组算法，将每一个算法封装到具有共同接口的独立的类中，从而使得它们可以相互替换。策略模式使得算法可以在不影响到客户端的情况下发生变化。 假设有这么一个需求： 一个系统，当用户消费满1000 金额，可以根据用户VIP等级，享受打折优惠。 根据用户VIP等级，计算出用户最终的费用。 普通会员 不打折白银会员 优惠50元黄金会员 8折白金会员 优惠50元，再打7折代码实例： /** */ public interface Strate
工厂模式和策略模式的实现
weixin_42742643的博客
09-08 286
本文实现多产品/多业务工厂类的配置和策略模式的实现。 抽象接口 import org.springframework.beans.factory.InitializingBean; public interface AbstractProducer extends InitializingBean { Object produce(); } 实现类 import org.springframework.stereotype.Component; @Component public class
【设计模式】策略模式+工厂模式实际应用
tl101120的博客
11-15 453
原始场景： 要根据传入的类型（operateType），做各自的初始化处理（为了方便看的更清晰，以下代码做了简化处理） 以下代码在controller层，在这种场景中用了很多if else，看起来就很臃肿吧 @RequestMapping("/toOperReport") public String toOperReport(String operateType) { String res...
7种常用的面向对象的设计原则
lxpume的专栏
02-09 164
面向对象设计的目标之一就是可维护性复用。包括： 1、设计方案和代码的复用 2、系统要易于扩展和修改 面向对象的设计原则就可以作为上述目标的指导方针，这些原则蕴含在很多的设计模式中，是前辈们从许多的设计方案中总结出来的指导性原则。 最常用的7种设计原则： 单一职责原则(Single Responsibility Principle, SRP)：一个类只负责一个功能领域中的相应职责 开闭原则(Open-Closed Principle, OCP)：软件实体应对扩展开放，对修改关闭 里氏替换原则(Liskov
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值