Как обрабатывать флаг в нескольких if-else

Я, кажется, вижу это достаточно часто в своем коде и других. В этом нет ничего ужасного, но меня это раздражает, поскольку кажется, что это можно сделать лучше. Я предполагаю, что оператор case может иметь немного больше смысла, но часто переменная является типом, который не работает хорошо или вообще не работает с операторами case (в зависимости от языка)

If variable == A
    if (Flag == true)
        doFooA()
    else
        doFooA2

else if variable == B
    if (Flag == true)
        doFooB()
    else
        doFooB2
else if variable == C
    if (Flag == true)
        doFooC()
    else
        doFooC2

Кажется, есть несколько способов «учесть» это, например, 2 набора if-elses, где один набор обрабатывает, когда Flag == true.

Есть ли «хороший способ» это учесть, или, возможно, когда происходит алгоритм «если-то еще», это обычно означает, что вы делаете что-то не так?

Это может быть обработано с полиморфизмом.

factory(var, flag).doFoo();

Всякий раз, когда у вас есть куча проверок if / else на тип чего-либо, вы можете подумать о централизации проверки if / else в фабричном методе с последующим полиморфным вызовом doFoo (). Но это может быть чрезмерным решением для одноразового решения.

Возможно, вы могли бы создать карту ключ / значение, где ключом является var / flag, а значением является сама функция.

do[var, flag]();

Несколько вложенных if увеличивают цикломатическую сложность кода. До недавнего времени наличие нескольких точек выхода в функциях считалось плохо структурированным кодом, но теперь, пока код прост и короток , вы можете сделать это, сделав код тривиальным для чтения:

    if (variable == A && Flag) {
        doFooA();
        return;
    }

    if (variable == A) {
        doFooA2();
        return;
    }

    if (variable == B && Flag){
        doFooB();
        return;
    }

    if (variable == B){
        doFooB2();
        return;
    }

    if (variable == C && Flag){
         doFooC();
         return;
    }

    if (variable == C){
         doFooC2();
    }

    return;

Другой вариант - объединить if и switch. Это не превосходит вашу вложенную технику, но может уменьшить количество повторяющихся тестов (если коммутатор оптимизируется под таблицу переходов).

if (flag)
{
    switch (variable)
    {
        case A:
           ... blah
           break;

        case B:
           ... blah
           break;

        case C:
           ... blah
           break;

        default:
           ... log an error.
           ... maybe do a default action.
           break;
    }
}
else // flag == false
{
    switch (variable)
    {
        case A:
           ... blah
           break;

        case B:
           ... blah
           break;

        case C:
           ... blah
           break;

        default:
           ... log an error.
           ... maybe do a default action.
           break;
}

Ну, всегда есть это ...

if variable == A && Flag
    doFooA()
else if variable == A 
    doFooA2    
else if variable == B && Flag
    doFooB()
else if variable == B
    doFooB2
else if variable == C && Flag
     doFooC()
else if variable == C
     doFooC2

Но, честно говоря, я думаю, что оригинальный код не так уж и плох.

Используйте полиморфизм и ruleмассив

interface IRule() {
  boolean applicable(args...);
  obj apply(args...);
}

static final Array<IRule> rules = [new MeaningfulNameRule1(), new MeaningfulNameRule2(), ...];

/* where */
class MeaningfulNameRuleX extends IRule{ /* */ }

/* In your method */

for (rule in rules) {
  if (rule.applicable(a,b,c)){
    return rule.apply(e,f,g);
  }
}

Или как mike30предложено: если условия правила могут легко сформировать ключ, тогда наилучшим способом будет использование хэш-карты.