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

最新推荐文章于 2024-09-07 23:32:00 发布
最新推荐文章于 2024-09-07 23:32: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
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
设计模式（一）：策略模式+简单工厂模式
花无名
04-06 1113
策略模式：      对同一个动作，在不同的时间有不同的算法；      对客户端隐藏算法的具体实现，彼此独立。 简单工厂模式：      通过一个类来确定产生哪一个实例。 接下来这个例子是对图像进行旋转，缩放，平移的操作。这个是策略模式和简单工厂模式的结合应用。 在对图像进行着三种操作的时候，读入图片，获取图像像素矩阵，显示图片，这些动作是都要进行的，因此提取出来，作为父类的
工厂模式+策略模式
zzwithk的博客
01-08 987
场景 目前遇到这样一个场景，就是会根据前端不同的传值执行对应的方法策略。按照正常思路，需要在代码中使用if判断前端的值来执行不同的方法。但这样做的缺点是会造成大量if判断，且下次新增加一个值对应一个策略，那么就需要改动代码。 解决 对于这种根据值来执行不同策略的场景，可以使用工厂模式+策略模式来解决。 既然有策略，那么我们就需要定义一个策略接口或策略抽象类。 public interface Strategy{ void doOperation(); String getStrategyN
unity大场景优化
07-08
unity3d 大场景 优化 遮挡 LOD 适合做大型的场景学习研究
场景优化
pdw_jsp的专栏
12-30 726
前言：场景优化网上一大堆，然而东爷肯定不会去抄人家的，东爷是有节操的LOD 是什么鬼首先要说的是著名的LOD，什么是LOD自己百度，简单说下他的实现原理：LOD是根据相机的距离对远距离的物体使用低模，进出使用高模的方式，这样带来的好处就是既不减少表现效果又能减少面数。这时候你是不是在想这样很吊，然并卵，手机上对那些需要处理lod的物体的脚本开销我大概计算了下，都比面数来的直接。（这里并不是绝对的，主
设计模式<面向对象的常用七大设计原则>
Gpwner的博客
02-28 1171
面向对象设计的目标之一在于支持可维护性复用，一方面需要实现设计方案或者源码的重用，另一方面要确保系统能够易于扩展和修改，具有较好的灵活性。 常用的设计原则有七个原则：1.单一职责原则（single responsibility principle，SPR） 一个类只负责一个功能领域中的相应职责。（或者可以定义为：就一个类而言，只有一个原因能够引起它变换）。 单一职责原则是实现高内聚、低耦合的指导
【Unity】场景优化
qq_26916435的博客
01-30 892
一、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
行为型设计模式则关注对象间的交互和责任分配，如观察者模式、策略模式、模板方法模式、命令模式、迭代器模式、职责链模式、备忘录模式、状态模式、访问者模式和解释器模式，这些模式能够使代码更加模块化，提高代码...
javascript模式设计中文版
12-30
这本书涵盖了多种在实际开发中常用的编程模式，包括设计模式、架构模式以及一些实用的编程技巧。 首先，我们要了解JavaScript是一种动态类型的语言，它的灵活性使得在编写代码时有很多不同的方法来解决问题。设计...
使用工厂模式+策略模式来优化代码结构
AnNanDu的博客
09-17 300
1. 业务场景 我们在新做的项目中有一个这样的应用场景，用户会导入不同平台的数据来存入mongodb中，不同平台的数据格式不一样，使用传统的mongoDB Model的方式需要建立太多的model，在后期维护上新加一个平台就需要增加一个model类重新上线一次，在可用性上不太合适，于是我考虑到工厂模式+策略模式来优化代码结构 2. 流程图 3. 代码 service interface service impl Strategy ...
策略模式+简单工厂-实际应用场景
01-11 2017
1、抽象策略接口 //抽象出他们共有的行为（支付行为） //从调用微信、支付宝、银联卡可以抽出一个公共的策略接口，同时也是为了实现定义中的互换 public interface PayStrategy { public void pay(float money); } 2、实现具体的策略 //支付宝支付的行为具体实现 public class AliPayStrategy im...
通过具体业务场景学习工厂模式与策略模式
qq_40126996的博客
02-05 177
入职新公司后熟悉业务过程中收到一个需求，优化一部分代码逻辑，优化时考虑业务的复杂性于是就想到使用设计模式优化这部分逻辑，将原来强耦合的逻辑拆分，便于以后的维护，分析之后确定使用工厂模式与策略模式。 先说下具体业务逻辑：首先业务逻辑中对象分为三个维度，分别为单票、大包、批次，每个维度需要执行不同的逻辑，执行逻辑就需要不同的策略来判断；这里策略有两种情况，分别为首次和重算，最后执行的逻辑则是请求其它服务的具体实现。 基于这种场景，首先考虑就是对于维度的拆分，单票、大包、批次都有不同的枚举状态来判断，..
代码重构：用工厂+策略模式优化过多的if else代码块
lppl010_的专栏
07-11 239
https://www.cnblogs.com/pfblog/p/7815238.html 最近在工作中优化了一段冗余的if else代码块，感觉对设计模式的理解和运用很有帮助，所以分享出来。鉴于原代码会涉及到公司的隐私，因此就不贴出来了。下面以更加通俗易懂的案例来解析。 假如写一个针对员工上班不遵守制度做相应惩罚的程序，比如，上班迟到：罚100；上班睡觉：罚1000；上班早退：警告；上...
使用工厂 + 策略模式优化if-else
人生就像一场戏
08-26 251
什么是策略模式？ 策略模式属于对象的行为模式。其用意是针对一组算法，将每一个算法封装到具有共同接口的独立的类中，从而使得它们可以相互替换。策略模式使得算法可以在不影响到客户端的情况下发生变化。 假设有这么一个需求： 一个系统，当用户消费满1000 金额，可以根据用户VIP等级，享受打折优惠。 根据用户VIP等级，计算出用户最终的费用。 普通会员 不打折白银会员 优惠50元黄金会员 8折白金会员 优惠50元，再打7折代码实例： /** */ public interface Strate
工厂模式和策略模式的实现
weixin_42742643的博客
09-08 285
本文实现多产品/多业务工厂类的配置和策略模式的实现。 抽象接口 import org.springframework.beans.factory.InitializingBean; public interface AbstractProducer extends InitializingBean { Object produce(); } 实现类 import org.springframework.stereotype.Component; @Component public class
漫谈设计模式 [11]：代理模式
最新发布
刘炫320的博客
09-07 815
老鸟：想象一下，你有一个朋友非常忙，你需要通过他的秘书与他联系。这个秘书就是你的代理，他可以帮你处理一些简单的事情，比如预约时间、传递信息等。这样，你的朋友就可以专注于他的重要工作。这就是代理模式的基本思想：通过代理对象来控制对实际对象的访问。菜鸟：哦，我明白了。代理对象就像是中间人，帮我们处理一些额外的事务。老鸟：没错。代理模式的核心思想就是在不改变原有对象的情况下，通过代理对象来添加额外的功能。老鸟：今天我们讨论了代理模式的核心思想、实现方法、优势以及适用场景。希望你能在实际项目中灵活应用。
PHP编程中的经典设计模式：实用模板与解决策略
设计模式并非具体的编程代码，而是一种设计思想或策略，它提供了一种结构化的框架来组织和优化代码，使代码更易于理解和复用。 设计模式的历史可以追溯到建筑学领域，如Christopher Alexander的《建筑模式语言》一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值