2

我想要一些关于重构以下方法的建议：

public boolean makeDecision(String group, int level, int primaryAmount, int secondaryAmount)
{
    if (group.equals("A"))
    {
        switch (level)
        {
            case 0 : return primaryAmount > 10000;break;
            case 1 : return primaryAmount > 20000;break;
            default : return secondaryAmount > 30000; break;
        }
    }
    else if (group.equals("B"))
    {
         switch (level)
         {
              case 0 : return primaryAmount > 40000;break;
              case 1 : return primaryAmount > 50000;break;
              default : return secondaryAmount > 60000; break;
         }

    }
    else if (group.equals("C"))
    {
        switch(level)
        {
            case 0 : return primaryAmount > 70000;break;
            case 1 : return primaryAmount > 80000;break;
            default : return secondaryAmount > 90000; break;
        }

    }
    return false;
}

我想达到的目标：

  • 允许代码遵循开放/封闭原则，因为及时会有更多的组/级别。
  • 删除“级别”开关语句中的重复项。
  • 理想情况下删除“组”顶级 switch 语句。
4

2 回答 2

1

由于每种情况都是通过简单的比较来计算的，因此您也可以使用任何一种方式进行所有比较。

所以这里有一个建议：

boolean[] aSol = { primary > 10000, primary > 20000, secondary > 30000 };
boolean[] bSol = { primary > 40000, primary > 50000, secondary > 60000 };
boolean[] cSol = { primary > 70000, primary > 80000, secondary > 90000 };

level = Math.min(level, 2);
return group.equals("A") ? aSol[level] :
       group.equals("B") ? bSol[level] :
       group.equals("C") ? cSol[level] :
       false;

我认为它具有相当的可读性和可维护性。

这是另一个稍微不同的公式：

boolean[][] result = {
        { primary > 10000, primary > 20000, secondary > 30000 },
        { primary > 40000, primary > 50000, secondary > 60000 },
        { primary > 70000, primary > 80000, secondary > 90000 } };

int groupId = Arrays.asList("A", "B", "C").indexOf(group);

if (groupId == -1)
    return false;

boolean[] groupResult = result[groupId];
return groupResult[Math.min(level, groupResult.length-1)];

另一种选择是使用方法创建接口

makeDecision(int level, int primaryAmount, int secondaryAmount)

然后Map<String, GroupDecision>用决策程序填充一个，

groupMap.put("A", new GroupDecision() { ... });
groupMap.put("B", new GroupDecision() { ... });
groupMap.put("C", new GroupDecision() { ... });

然后打电话

return groupMap.get(group).makeDecision(level, primaryAmount, secondaryAmount);

这种方法可能是最具扩展性和可读性的方法。

于 2012-05-09T07:59:39.703 回答
1

群体看起来像是有行为的。您可以将字符串组提升为一流类型。您还可以在类上放置方法来表示您拥有的逻辑。我把愚蠢的名字放在变量上，他们可以用更好的名字。

public class Group {
    public static Group A = new Group(10000,20000,30000);
    public static Group B = new Group(40000,50000,60000);
    public static Group C = new Group(70000,80000,90000);

    private int primaryMin;
    private int primaryMid;
    private int secondaryMax;

    private Group(int min, int mid, int max) {
        primaryMin = min;
        primaryMid = mid;
        secondaryMax = max;
    }

    public boolean getLevel(int level, int primaryAmount, int secondaryAmount) {
       if (level == 0)
         return primaryAmount > primaryMin;
       else if (level == 1) 
         return primaryAmount > primaryMid;
       else 
         return secondaryAmount > secondaryMax;
    }
}

因此，现在您可以将顶级语句减少到

public boolean makeDecision(Group group, int level, int primaryAmount, int secondaryAmount) {
  return group.getLevel(level, primaryAmount, secondaryAmount);
}

您可能希望考虑使用空对象模式来处理未知组。

如果您说级别会随着时间的推移而增长，那么我会考虑再次做几乎完全相同的操作来引入Level该类并将 if/else 链作为另一层 polymorphshim 推入其中。这将成为双重分派模式，因为首先您将分派 of 的类型，Group然后分派 . 的类型Level。这应该意味着您可以添加新代码而无需修改现有代码。

于 2012-05-09T08:19:13.130 回答