Nested if conditions

Question

I'm facing huge problems with nested if conditions in our core java application An abstract of code is as below....we can have nearly 20 nested if conditions can you tell me how to optimize this piece of code ?

what is a better way of avoiding this nested if conditions in java.i can have 20 nested if conditions and that could be a huge problem from design perspective of Java Application.

Please help with a solution in java Java Version 1.6

String condition = getCondition();
if (condition.equals(add)) { // add operation
    add();
    if (condition.equals(sub)) {// sub operation
        sub();
        if (condition.equals(div)) { //div operation
            div();
            if (condition.equals(cos)) { // cos operation
                cos();
            }
        }
    }
}

EDIT: I can have more mathematical operations say 20 more,will switch work then.20 operations is a huge lot.

Answer 1

You should use if else-if condition instead like this:

String condition = getCondition();      
if(condition.equals(add))
    add();   
else if(condition.equals(sub)) 
    sub();   
else if(condition.equals(div))   
    div();   
else if(condition.equals(cos))   
    cos();  

Answer 2

Use switch statement instead. Use this when you have alot of decision.

Note that this can only happen with JDK 7 when you want to use a String in switch statement. In older version enum might be helpful.

Answer 3

State Pattern :

public enum Operation {
ADD {
    int execute(int a, int b) {
        return a + b;
    }
},
SUB {
    int execute(int a, int b) {
        return a - b;
    }
},
MUL {
    @Override
    int execute(int a, int b) {
        return a * b;
    }
},
DIV {
    @Override
    int execute(int a, int b) {
        return a / b;
    }
};

abstract int execute(int a, int b);

public static void main(String[] args) {
    Operation oper = getOperation();
    oper.execute(3, 4);
}

private static Operation getOperation() {
    return Operation.MUL;
}

}

like this:

public static void main(String[] args) {
    String operation = user set it
    Operation oper = getOperation(operation);
    oper.execute(3, 4);
}

private static Operation getOperation(String operation) {
    return Operation.valueOf(operation.toUpperCase());
}

be careful that Operation.valueOf may throw NullPointerException if operation is null or IllegalArgumentException if operation is not one of Operation enum

Answer 4

If the if statments do not need to be nested, then you can use a command pattern.

First, setup a mapping between matcher and commands. The commands adhere to a common invoke interface such as Runnable, Callable or as in my example Command. The example shows how to create the wrapper dynamically and using static or non static classes. This pattern is practical if the actual commands are not known before hand as it is possible to later add and remove commands.

public class CommandExample {

    private interface Command {
        public void execute();
    }

    private Map<String, Command> commands = new HashMap<>();

    private void setUp() {
        commands.put("add", new Command() {
            public void execute() {
                add();
            }
        });
        commands.put("sub", new Sub());
        commands.put("arg", new Argument("the argument"));
    }

    private void add() {
        System.out.println("Add called");
    }

    private static class Sub implements Command {
        @Override
        public void execute() {
            System.out.println("Sub called");
        }
    }

    private class Argument implements Command {

        private final String arg;

        public Argument(String arg) {
            this.arg = arg;
        }

        @Override
        public void execute() {
            System.out.println("Argument called with arg " + arg
                    + " and access to outer class " + CommandExample.this);
        }
    }

    private void execute(String... names) {
        for (String name : names) {
            Command command = commands.get(name);
            if (command != null) {
                command.execute();
            } else {
                System.err.println("Command '" + name
                        + "' is not known. Only know " + commands.keySet());
            }
        }
    }

    public static void main(String[] args) {
        CommandExample commandExample = new CommandExample();
        commandExample.setUp();
        commandExample.execute("add", "sub", "arg", "unknown");
    }
}

Answer 5

Here you have example of how you can use enums for this. First create your enum

enum MathOperations{
    ADD, SUB, DIV, COS;
}

Then you can use it like this

MathOperations m = MathOperations.valueOf(getCondition().toUpperCase);
switch(m) {
    case ADD: add(); break;
    case SUB: sub(); break;
    //and so on...
}

Of course it will only work if getCondition() will return element that is MathOperations. Otherwise you will get IllegalArgumentException.

---

You can also try to use Strategy pattern.

Answer 6

You can put add, sub, div, cos… into an ordered list/ array. Then use a for loop to iterate the list. Use break operator and reflection to call appropriate methods.

final String[] OPERATION_LIST = { "add", "sub", "div", "cos" };
String condition = getCondition();
for (String op : OPERATION_LIST) {
    if (condition.equals(op))
        getClass().getMethod(op).invoke(this);
    else
        break;
}

The above for loop equals to your nested if statements. The drawback is other math methods must be public. If not, you need something like Accessing Private Methods.

A note: If you're making a calculator (are you?), maybe Reverse Polish notation is better.

Answer 7

According to your code it should always satisfy condition.equals(add) to execute next lines.According to conditions in net lines it never satisfy next condition .When it will come into next lines of code ?.

To check with number of String conditions

You can use switch.

 String condition = getCondition();    
  switch(condition ) {
        case add:
            add();
            break;
        case sub:
            sub();
            break;
        // etc...
    }

Side note:Switch on strings available from Java7.