0
点赞
收藏
分享

微信扫一扫

写给所有程序员_你的逻辑不要太贪心

十日十月Freddie 2022-07-12 阅读 45
程序员逻辑i++选择结构数据OpenStack云计算


有的时候，可能一段逻辑代码需要大量的运算，为了偷懒，我们把本不该写在一起的东西勉强拼凑在一起。

1.贪心的函数（贪心的方法）

例子：

public static void main(String[]args){
    int firstNum = 5;
    int secondNum = 3;
    System.out.println(getSumOfTwoNums(firstNum,secondNum));
    //doSomething...
    System.out.println(getSumOfTwoNums(5,2));
}

public static int getSumOfTwoNums(int firstNum,int secondNum){
    ++firstNum;
    return

发现问题了吗？求和函数（方法）里面竟然有一句++firstNum;！！！第一次用的时候，可能是因为某种需要，所以需要把firstNum加一。为了方便，把它和后面的相加写在一起了。这样后面用的时候可能导致错误，因为后面用到的时候你已经忘记了这个函数（方法）里面你居然一时脑抽把加一这样的代码写在里面了。
贪心：你的函数和方法把没提到的事顺便做了。
修改：不要做你的函数（方法）没有提到的事，这可能导致你后面的调用造成隐患。

正确的做法：

public static void main(String[] args){
    int firstNum = 5;
    int secondNum = 3;
    System.out.println(getSumOfTwoNums(firstNum+1,secondNum));
    //doSomething...
    System.out.println(getSumOfTwoNums(5,2));
}

public static int getSumOfTwoNums(int firstNum,int secondNum){
    return

2.贪心的选择结构

public static void main(String[] args){
    int CODE_A = 1;
    int CODE_B = 2;

    //doSomething

    int firstNum = 5;
    int secondNum = 3;
    int thirdNum  8;
    int fourthNum = 2;

    int sum = 0;
    int difference = 0;
    if(CODE_A > CODE_B){
        sum = thirdNum  + fourthNum;
        difference = fourthNum - thirdNum;
    }else if(CODE_A == CODE_B){
        difference = firstNum - secondNum;
    }else{
        sum

上面的例子要讲的是达到某些条件要做一些操作，暂时以CODE_A,CODE_B为例子，表示某状态暂时以这种方式代替。sum表示求的和，difference表示求的差。
贪心：把这两个逻辑写在同一段代码里面了，虽然两者并没有关系。
修改：把不同部分的代码逻辑分开。
正确的做法：

public static void main(String[] args){
    int CODE_A = 1;
    int CODE_B = 2;

    //doSomething

    int firstNum = 5;
    int secondNum = 3;
    int thirdNum  8;
    int fourthNum = 2;

    int sum = 0;
    if(CODE_A > CODE_B){
        sum = thirdNum  + fourthNum;
    }else if(CODE_A < CODE_B){
        sum = thirdNum  + secondNum;
    }

    int difference = 0;
    if(CODE_A > CODE_B){
        difference = fourthNum - thirdNum;
    }else if(CODE_A == CODE_B){
        difference = firstNum - secondNum;
    }
}

可以看到，虽然代码判断了两次，但是逻辑更清晰了，因为很多时候，贪心并不满足全匹配，这个改一下，那个又改一下，可能你第一次写的时候很爽：只要写一次。但后面看的时候，保证你会疯掉。而且，贪心写法，不方便分割，像上面的代码，可以改成这样：

选择结构贪心识别：一个选择结构if…else if(…)…else不能使用一个函数（方法）表达出来

public class TestGreedy{
    private int CODE_A = 1;
    private int CODE_B = 2;

    int firstNum = 5;
    int secondNum = 3;
    int thirdNum  8;
    int fourthNum = 2;

    public static void main(String[] args){
        TestGreedy greedy = new TestGreedy();

        int sum = getSumByCode();
        int diference = getDifferenceByCode();
    }

    public int getSumByCode(){
        if(CODE_A > CODE_B){
            return thirdNum  + fourthNum;
        }else if(CODE_A < CODE_B){
            return thirdNum  + secondNum;
        }
        return 0;
    }

    public int getDifferenceByCode(){
        if(CODE_A > CODE_B){
            return fourthNum - thirdNum;
        }else if(CODE_A == CODE_B){
            return firstNum - secondNum;
        }
        return 0;
    }
}

因为不贪心，所以if…else存在完整的逻辑含义，所以我们可以把它们单独放到函数（方法）里面，这样看起来，马上清爽了，而这种做法的前提是：不要太贪心，又求和又求差，很难以一个函数（方法）表达它的意思。

补充：特殊情况：点击控件的识别和数据返回，这种情况不属于逻辑问题导致的，不作为贪心逻辑理论的考虑范围。

public void onClick(View v){
    swich(v.getId()){
        case ...:break;
        case ...:break;
    }
}

3.贪心的循环结构

public static void main(String[] args){
        TestGreedy greedy = new TestGreedy();

        int arrNums = new int[]{2,4,5,6};

        int sum = 0;
        int muti = 1;
        for(int i = 0; i < arrNums.size(); i++){
            sum += arrNums[i];
            muti *= arrNums[i];
        }
    }

贪心：一个循环里面做了多件事
首先，不能不承认，你很“聪明”，从逻辑的角度讲你把O(2n)的时间复杂度降低到O(n)。但实际上，它的指数级别还是一样的，都是n级别！！！。除非数据量非常大（数组级别在千万以上），否则这样做除了搞乱逻辑只外，实在没有什么太重大的意义。

修改后的代码：

public static void main(String[] args){
        int[] nums = new int[]{2,4,5,6};

        int sum = 0;
        for(int i = 0; i < nums .size(); i++){
            sum += nums [i];
        }

        int muti = 1;
        for(int i = 0; i < nums .size(); i++){
            muti *= nums [i];
        }
}

同样，我们可以单独把它拆分到单独的函数或者方法当中：

public static void main(String[] args){
        int[] nums = new int[]{2,4,5,6};

        int sum =   getSumOfNums(nums);
        int muti = getMutiOfNums(nums);
}

public static int getSumOfNums(int[] nums){
    int sum = 0;
    for(int i = 0; i < nums .size(); i++){
        sum += nums [i];
    }
}

public static int getMutiOfNums(int[] nums){
    int muti = 1;
    for(int i = 0; i < nums .size(); i++){
        muti *= nums [i];
    }
}

循环结构贪心识别：一个选择结构for(…){}不能使用一个函数（方法）表达出来

4.贪心的变量

public static void main(String[] args){
        int sum = 0;
        for(int i = 0; i < arrNums.size(); i++){
            sum += arrNums[i];
        }
        sum -= 5;
        System.out.println(sum);
    }

你的和有表达它会减少的含义么？你确定这样使用不会出错？在我看来，这种一个变量两种用途的方式，除了给你后面的代码造成困惑和麻烦外，没什么太有用的地方，正确的写法是：

public static void main(String[] args){
        int sum = 0;
        for(int i = 0; i < arrNums.size(); i++){
            sum += arrNums[i];
        }
        int offsetSum -= 5;
        System.out.println(offsetSum);
    }

贪心变量的特点是，你对变量做了某件事情，可完全无法用原有的变量名称看出它有表达有做这件事情的意向

实例

补充：一直在想一个例子，怎么讲不贪心的好处更加具体，然后重新改了一下公司一个计算价格的逻辑，当然，由于保密不能贴出来，所以打算用一个叫外卖的例子，因为这个可以足够复杂。

假设收外卖费是这样收的（虚拟的，非真实）：外卖费由食物费,餐具费,送货费,红包,优惠（满100-22）组成，然后计算。

public double getTakeOutFoodCost(){
    double foodCost = 0;
    double tableWareCost = 0;
    double redPacketCost = 0;
    double realCost = 0;//实际价格（不减）
    double fillSubMoney = 0;

    for(FoodBean foodBean:foodBeans){
        foodCost += foodBean.getCost();
    }

    takeOutBean.setFoodCost(foodCost);

    tableWareCost = takeOutBean.getNumOfPeople() * takeOutBean.getSingleTableWareCost();

    takeOutBean.setTableWareCost(tableWareCost);

    if(takeOutBean.getRedPacketCost()!=0){
        takeOutBean.setCostByRedPacket(1);
        redPacketCost = takeOutBean.getRedPacketCost();
        foodCost = (foodCost -tableWareCost.getRedPacketCost()>0)?foodCost -tableWareCost.getRedPacketCost():0;
        if(takeOutBean.needDeliveryCost())
            foodCost += foodBean.getDeliveryCost();
        realCost = foodCost + tableWareCost+foodBean.getDeliveryCost()+tableWareCost.getRedPacketCost();
    }else{
        takeOutBean.setCostByRedPacket(0);
        if(takeOutBean.needDeliveryCost())
            foodCost += foodBean.getDeliveryCost();
        realCost = foodCost + tableWareCost+foodBean.getDeliveryCost();
    }

    takeOutBean.setRealCost(realCost);

    fillSubMoney = realCost/100 * 22;

    takeOutBean.setFillSubMoney(fillSubMoney);
    return  foodCost + tableWareCost - redPacketCost - fillSubMoney;

首先，我们分析到这个函数（方法）本质是让我们获取各种价钱，然后返回的。但是这个方法里面放了太多的东西（实际还好，我看的那个有五层if…）：
1.这个方法名说明了是用于获取外卖价钱的，但此方法对于takeOutBean（外卖对象）以各种姿势进行设置，你确定以后还能找的到？

2.foodCost,这应该指的是食物费吧？为何要减红包费，为何要加送货费？注意到你的realCost实际上把快递费算了两次吗？注意到最后又减了一次红包吗？这就是变量贪心的后果。

3.以下代码再if,else都有写到，这是贪心太多，自己都看不清代码的时候，很容易犯的错误，实际上，当你的代码够少，逻辑不贪心的时候完全不会犯这样的错误：

if(takeOutBean.needDeliveryCost())
            foodCost += foodBean.getDeliveryCost();

好了，现在对这个复杂的函数进行改造。

第一步，分离takeOutBean的设置和价格计算部分

public void payMoney(){
    int takeOutFoodCost = getTakeOutFoodCost();
    setTakeOutBeanData();
    //doSomething
}

public void setTakeOutBeanData(){

}

大致结构是这样的，然后我们先把getTakeOutFoodCost()的代码复制一份到setTakeOutBeanData()里面变成：

public void payMoney(){
    int takeOutFoodCost = getTakeOutFoodCost();
    setTakeOutBeanData();
    //doSomething
}

public void setTakeOutBeanData(){
    double foodCost = 0;
    double tableWareCost = 0;
    double redPacketCost = 0;
    double realCost = 0;//实际价格（不减）
    double fillSubMoney = 0;

    for(FoodBean foodBean:foodBeans){
        foodCost += foodBean.getCost();
    }

    takeOutBean.setFoodCost(foodCost);

    tableWareCost = takeOutBean.getNumOfPeople() * takeOutBean.getSingleTableWareCost();

    takeOutBean.setTableWareCost(tableWareCost);

    if(takeOutBean.getRedPacketCost()!=0){
        takeOutBean.setCostByRedPacket(1);
        redPacketCost = takeOutBean.getRedPacketCost();
        foodCost = (foodCost -tableWareCost.getRedPacketCost()>0)?foodCost -tableWareCost.getRedPacketCost():0;
        if(takeOutBean.needDeliveryCost())
            foodCost += foodBean.getDeliveryCost();
        realCost = foodCost + tableWareCost+foodBean.getDeliveryCost()+tableWareCost;
    }else{
        takeOutBean.setCostByRedPacket(0);
        if(takeOutBean.needDeliveryCost())
            foodCost += foodBean.getDeliveryCost();
        realCost = foodCost + tableWareCost+foodBean.getDeliveryCost();
    }

    takeOutBean.setRealCost(realCost);

    fillSubMoney = realCost/100 * 22;

    takeOutBean.setFillSubMoney(fillSubMoney);
    return  foodCost + tableWareCost - redPacketCost - fillSubMoney;
}

public double getTakeOutFoodCost(){
    double foodCost = 0;
    double tableWareCost = 0;
    double redPacketCost = 0;
    double realCost = 0;//实际价格（不减）
    double fillSubMoney = 0;

    for(FoodBean foodBean:foodBeans){
        foodCost += foodBean.getCost();
    }

    takeOutBean.setFoodCost(foodCost);

    tableWareCost = takeOutBean.getNumOfPeople() * takeOutBean.getSingleTableWareCost();

    takeOutBean.setTableWareCost(tableWareCost);

    if(takeOutBean.getRedPacketCost()!=0){
        takeOutBean.setCostByRedPacket(1);
        redPacketCost = takeOutBean.getRedPacketCost();
        foodCost = (foodCost -tableWareCost.getRedPacketCost()>0)?foodCost -tableWareCost.getRedPacketCost():0;
        if(takeOutBean.needDeliveryCost())
            foodCost += foodBean.getDeliveryCost();
        realCost = foodCost + tableWareCost+foodBean.getDeliveryCost()+tableWareCost;
    }else{
        takeOutBean.setCostByRedPacket(0);
        if(takeOutBean.needDeliveryCost())
            foodCost += foodBean.getDeliveryCost();
        realCost = foodCost + tableWareCost+foodBean.getDeliveryCost();
    }

    takeOutBean.setRealCost(realCost);

    fillSubMoney = realCost/100 * 22;

    takeOutBean.setFillSubMoney(fillSubMoney);
    return

代码暂时性的变多了，看的好乱，好想吐。。。为了整洁，为了优雅，为了不贪心，我们姑且忍受，现在，我们把所有getTakeOutFoodCost()中设置takeOutBean的部分全部删掉,把setTakeOutBeanData()的所有非takeOutBean设置部分全部删掉：

第二步，删除getTakeOutFoodCost()设置takeOutBean的部分,删除setTakeOutBeanData()的所有非takeOutBean设置部分

public void payMoney(){
    int takeOutFoodCost = getTakeOutFoodCost();
    setTakeOutBeanData();
    //doSomething
}

public void setTakeOutBeanData(){
    takeOutBean.setFoodCost(foodCost);
    takeOutBean.setTableWareCost(tableWareCost);

    if(takeOutBean.getRedPacketCost()!=0){
        takeOutBean.setCostByRedPacket(1);
    }else{
        takeOutBean.setCostByRedPacket(0);
    }

    takeOutBean.setRealCost(realCost);
    takeOutBean.setFillSubMoney(fillSubMoney);
}

public double getTakeOutFoodCost(){
    double foodCost = 0;
    double tableWareCost = 0;
    double redPacketCost = 0;
    double realCost = 0;//实际价格（不减）
    double fillSubMoney = 0;

    for(FoodBean foodBean:foodBeans){
        foodCost += foodBean.getCost();
    }

    tableWareCost = takeOutBean.getNumOfPeople() * takeOutBean.getSingleTableWareCost();

    if(takeOutBean.getRedPacketCost()!=0){
        foodCost = (foodCost -tableWareCost.getRedPacketCost()>0)?foodCost -tableWareCost.getRedPacketCost():0;
        if(takeOutBean.needDeliveryCost())
            foodCost += foodBean.getDeliveryCost();
        realCost = foodCost + tableWareCost+foodBean.getDeliveryCost()+tableWareCost;
    }else{
        if(takeOutBean.needDeliveryCost())
            foodCost += foodBean.getDeliveryCost();
        realCost = foodCost + tableWareCost+foodBean.getDeliveryCost();
    }

    fillSubMoney = realCost/100 * 22;
    return

好吧，依然乱的要命，不过setTakeOutBeanData()里面已经初见成效了，这里的错误现在先不管它。现在把getTakeOutFoodCost()的foodCost权责分开，把realCost的计算错误纠正：

第三步，分离getTakeOutFoodCost()的权责

public void payMoney(){
    int takeOutFoodCost = getTakeOutFoodCost();
    setTakeOutBeanData();
    //doSomething
}

public void setTakeOutBeanData(){
    takeOutBean.setFoodCost(foodCost);
    takeOutBean.setTableWareCost(tableWareCost);

    if(takeOutBean.getRedPacketCost()!=0){
        takeOutBean.setCostByRedPacket(1);
    }else{
        takeOutBean.setCostByRedPacket(0);
    }

    takeOutBean.setRealCost(realCost);
    takeOutBean.setFillSubMoney(fillSubMoney);
}

public double getTakeOutFoodCost(){
    double foodCost = 0;
    double tableWareCost = 0;
    double redPacketCost = 0;
    double deliveryCost = 0;
    double realCost = 0;//实际价格（不减）
    double fillSubMoney = 0;

    for(FoodBean foodBean:foodBeans){
        foodCost += foodBean.getCost();
    }

    tableWareCost = takeOutBean.getNumOfPeople() * takeOutBean.getSingleTableWareCost();

    if(takeOutBean.getRedPacketCost()!=0){
        redPacketCost = takeOutBean.getRedPacketCost(); 
    }

    if(takeOutBean.needDeliveryCost())
            deliveryCost =  foodBean.getDeliveryCost();
    realCost = foodCost + tableWareCost+deliveryCost +tableWareCost;

    fillSubMoney = realCost/100 * 22;

    return

然后稍微整理一下，代码整齐了好多，注意返回的数据要加上送货费deliveryCost，实际上，红包价格是否为零对获取红包价格完全没影响不是吗？那么if(takeOutBean.getRedPacketCost()!=0){}的判断可以去掉了：

第四步，去除无效的判断：

public void payMoney(){
    int takeOutFoodCost = getTakeOutFoodCost();
    setTakeOutBeanData();
    //doSomething
}

public void setTakeOutBeanData(){
    takeOutBean.setFoodCost(foodCost);
    takeOutBean.setTableWareCost(tableWareCost);

    if(takeOutBean.getRedPacketCost()!=0){
        takeOutBean.setCostByRedPacket(1);
    }else{
        takeOutBean.setCostByRedPacket(0);
    }

    takeOutBean.setRealCost(realCost);
    takeOutBean.setFillSubMoney(fillSubMoney);
}

public double getTakeOutFoodCost(){
    double foodCost = 0;
    double tableWareCost = 0;
    double redPacketCost = 0;
    double deliveryCost = 0;
    double realCost = 0;//实际价格（不减）
    double fillSubMoney = 0;

    for(FoodBean foodBean:foodBeans){
        foodCost += foodBean.getCost();
    }

    tableWareCost = takeOutBean.getNumOfPeople() * takeOutBean.getSingleTableWareCost();

    redPacketCost = takeOutBean.getRedPacketCost(); 


    if(takeOutBean.needDeliveryCost())
            deliveryCost =  foodBean.getDeliveryCost();
    realCost = foodCost + tableWareCost+deliveryCost +tableWareCost;

    fillSubMoney = realCost/100 * 22;

    return

然后，我们可以发现，每种价格都已经完美的分割开了，可以独立成函数了：

第五步，独立各种价格成函数

public void payMoney(){
    int takeOutFoodCost = getTakeOutFoodCost();
    setTakeOutBeanData();
    //doSomething
}

public double getTakeOutFoodCost(){
    return  getFoodCost()+ getTableWareCost()+ getDeliveryCost()- takeOutBean.getRedPacketCost()- getFillSubMoney();
}
public void setTakeOutBeanData(){
    takeOutBean.setFoodCost(foodCost);
    takeOutBean.setTableWareCost(tableWareCost);

    if(takeOutBean.getRedPacketCost()!=0){
        takeOutBean.setCostByRedPacket(1);
    }else{
        takeOutBean.setCostByRedPacket(0);
    }

    takeOutBean.setRealCost(realCost);
    takeOutBean.setFillSubMoney(fillSubMoney);
}



private double getFillSubMoney(){
    return getRealCost()/100 * 22;
}

public double getRealCost(){
    return getFoodCost() + getTableWareCost() + takeOutBean.getRedPacketCost() + getDeliveryCost();
}

public double getFoodCost(){
    double foodCost = 0;
    for(FoodBean foodBean:foodBeans){
        foodCost += foodBean.getCost();
    }
    return foodCost;
}

public double getTableWareCost(){
    return takeOutBean.getNumOfPeople() * takeOutBean.getSingleTableWareCost();
}

public double getDeliveryCost(){
    if(takeOutBean.needDeliveryCost())
        return foodBean.getDeliveryCost();
    return 0;
}

棒极了，非常整洁！所有的地方最多只有一层！此时可以发现，上面的setTakeOutBeanData()竟然很容易就可以改好了：

第五步，修改setTakeOutBeanData()

public void payMoney(){
    int takeOutFoodCost = getTakeOutFoodCost();
    setTakeOutBeanData();
    //doSomething
}

public void setTakeOutBeanData(){
    takeOutBean.setFoodCost(getFoodCost());
    takeOutBean.setTableWareCost(getTableWareCost());

    if(takeOutBean.getRedPacketCost()!=0){
        takeOutBean.setCostByRedPacket(1);
    }else{
        takeOutBean.setCostByRedPacket(0);
    }

    takeOutBean.setRealCost(getRealCost());
    takeOutBean.setFillSubMoney(getFillSubMoney());
}

public double getTakeOutFoodCost(){
    return  getFoodCost()+ getTableWareCost()+ getDeliveryCost()- takeOutBean.getRedPacketCost()- getFillSubMoney();
}

public double getRealCost(){
    return getFoodCost() + getTableWareCost() + takeOutBean.getRedPacketCost() + getDeliveryCost();
}

public double getFoodCost(){
    double foodCost = 0;
    for(FoodBean foodBean:foodBeans){
        foodCost += foodBean.getCost();
    }
    return foodCost;
}

public double getTableWareCost(){
    return takeOutBean.getNumOfPeople() * takeOutBean.getSingleTableWareCost();
}

public double getDeliveryCost(){
    if(takeOutBean.needDeliveryCost())
        return foodBean.getDeliveryCost();
    return 0;
}


public double getFillSubMoney(){
    return getRealCost()/100 * 22;
}

setTakeOutBeanData()里面有个if…else，把这个放出来效果更好：

第六步，抽离设置里面的if…else

public void payMoney(){
    int takeOutFoodCost = getTakeOutFoodCost();
    setTakeOutBeanData();
    //doSomething
}

public void setTakeOutBeanData(){
    takeOutBean.setFoodCost(getFoodCost());
    takeOutBean.setTableWareCost(getTableWareCost());
    takeOutBean.setCostByRedPacket(getTypeByRedPacketCost());
    takeOutBean.setRealCost(getRealCost());
    takeOutBean.setFillSubMoney(getFillSubMoney());
}

public int getTypeByRedPacketCost(){
    return takeOutBean.getRedPacketCost()==0?0:1;
}

public double getTakeOutFoodCost(){
    return  getFoodCost()+ getTableWareCost()+ getDeliveryCost()- takeOutBean.getRedPacketCost()- getFillSubMoney();
}

public double getRealCost(){
    return getFoodCost() + getTableWareCost() + takeOutBean.getRedPacketCost() + getDeliveryCost();
}

public double getFoodCost(){
    double foodCost = 0;
    for(FoodBean foodBean:foodBeans){
        foodCost += foodBean.getCost();
    }
    return foodCost;
}

public double getTableWareCost(){
    return takeOutBean.getNumOfPeople() * takeOutBean.getSingleTableWareCost();
}

public double getDeliveryCost(){
    if(takeOutBean.needDeliveryCost())
        return  foodBean.getDeliveryCost();
    return 0;
}


public double getFillSubMoney(){
    return getRealCost()/100 * 22;
}

第七步，为了阅读方便，我们调换一下各个函数的顺序：

public void payMoney(){
    int takeOutFoodCost = getTakeOutFoodCost();
    setTakeOutBeanData();
    //doSomething
}


public double getTakeOutFoodCost(){
    return  getFoodCost()+ getTableWareCost()+ getDeliveryCost()- takeOutBean.getRedPacketCost()- getFillSubMoney();
}

public void setTakeOutBeanData(){
    takeOutBean.setFoodCost(getFoodCost());
    takeOutBean.setTableWareCost(getTableWareCost());
    takeOutBean.setCostByRedPacket(getTypeByRedPacketCost());
    takeOutBean.setRealCost(getRealCost());
    takeOutBean.setFillSubMoney(getFillSubMoney());
}

public double getFoodCost(){
    double foodCost = 0;
    for(FoodBean foodBean:foodBeans){
        foodCost += foodBean.getCost();
    }
    return foodCost;
}


public double getTableWareCost(){
    return takeOutBean.getNumOfPeople() * takeOutBean.getSingleTableWareCost();
}


public double getDeliveryCost(){
    if(takeOutBean.needDeliveryCost())
            return  foodBean.getDeliveryCost();
    return 0;
}

public double getFillSubMoney(){
    return getRealCost()/100 * 22;
}

public double getRealCost(){
    return getFoodCost() + getTableWareCost() + takeOutBean.getRedPacketCost() + getDeliveryCost();
}


public int getTypeByRedPacketCost(){
    return takeOutBean.getRedPacketCost()==0?0:1;
}

现在这段代码终于“合格”了，看计算收费的代码：

public double getTakeOutFoodCost(){
    return  getFoodCost()+ getTableWareCost()+ getDeliveryCost()- takeOutBean.getRedPacketCost()- getFillSubMoney();
}

马上知道是收费=食物费+餐具费+送货费-红包-满减，然后如果后期有修改，改需要的地方就可以了。意识到了吗？实际上，只要我们把贪心的权责分开，然后就能够把各个分离出的部分写成函数（方法），我们的代码量实际上并没有增加多少，但是逻辑上更清晰了，各变量的耦合都降低，易读性和可扩展性都有显著的提升。


举报

相关推荐

写给所有程序员_你的逻辑可以更简洁易读吗？

程序员异常处理二分查找顺序查找编程语言

写给所有程序员_你的函数（方法）还好吗？

程序员方法名封装性时间格式编程语言

写给所有程序员_寻求更优解_你值得更好的

程序员选择图片开源项目i++编程语言

写给所有程序员_if...else简化研究

程序员编程逻辑表达式逻辑判断嵌套编程语言

如何让你的程序员不要厌倦工作？

程序员心理研发管理数据微服务数据库编程语言

写给年轻程序员的几点启示

系统设计优秀程序员码农Python后端开发

程序员的幽默-献给所有Java程序员

小程序我爱编程ios实用开发技巧

程序员要不要考研

读研外包javaOffice办公

写给所有程序员_起个好名字是成功的一半

程序员变量名ide控件编程语言

写给程序员的有效的平上沟通技术

elk
0 条评论