Question

I’m having problem with this function in Java. I don’t understand why when lastNodeAttributes==null is true execution jumps to return null; as should, but right after that, instead of returning from function it jumps directly to return fight...; at the very end. Why first return doesn’t exit but execution jumps to return in second conditional part?? How is this even possible? Please explain cause obviously I don’t understand how basics of java work.

public Node undo() {
    Node lastNode=fight.getLastChild();
    NamedNodeMap lastNodeAttributes = lastNode.getAttributes();
    if(lastNodeAttributes == null) { return null; }
    else { 
        String lastNodeFighter = lastNodeAttributes.getNamedItem("fighter")
                                 .getNodeValue();
        String lastNodePoints = lastNodeAttributes.getNamedItem("points")
                                .getNodeValue();
        if(Integer.parseInt(lastNodeFighter) == 1) {
            fighter1score-=Integer.parseInt(lastNodePoints);    
        }
        else { fighter2score -= Integer.parseInt(lastNodePoints); }
        return fight.removeChild(fight.getLastChild());
    }
}

Answer 1

What you’re describing is impossible. A return statement does indeed always return what is stated. There are a few possibilities to why you might see this behaviour in the debugger

• You’re not debugging the code you think you’re debugging. The debugger might be loading a different class than you think. Try to clean and recompile your code and debug it again.
• The code is compiled in release mode, and has switched your statements around. Debugging in release mode with optimized code can sometimes throw the debugger off so that the wrong statement shows as executed in your debugger than what is actually executed. Are you sure that the code you’re debugging is unoptimized.
• Threading issues can also cause strange jumps if you don’t think carefully. If you have breakpoints on both return statements and multiple threads running then one thread might hit the first return, and then another thread might hit the second return. It’s not wrong, it’s just how debugging multithreaded applications work.

Checking the actual return value will also confirm that indeed only one return statement has executed. Do this by placing the breakpoint at the caller instead of the callee