Java is asking to return a value even when the value is returned in the if-else ladder

I was trying to code AVL tree in java and something has just shaken my understanding of basic programming. Why does Java force me to return a value when I already have a return statement in the else block of the if-else ladder. I tried debugging and it works as expected, it never goes to the returns statement outside the if-else blocks. I have been working on java and never realized this. I am not even sure if this was always there or is it something new? I also read a few blogs which say that you don't have to return a value if you have returned it from the else block.

The error which I get is I skip the last return statement.
Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
	This method must return a result of type AVLNode

https://javahungry.blogspot.com/2019/12/missing-return-statement-in-java.html
checkout the last example on this link.

public class AVL 
{
	AVLNode root;
	
	private AVLNode insert ( AVLNode current,int val)
	{
		if ( current == null)
		{
			return new AVLNode(val, 0, null, null);
		}
		else if ( val < current.val)
		{
			current.left = insert ( current.left, val);
		}
		else if ( val > current.val)
		{
			current.right = insert ( current.right, val);
		}
		else
		{
			return current;
		}
		return current;		// I don't want to return you ////		
	}


public void  add ( int val)
	{
		this.root = insert ( this.root, val);
	}

you either use

else

    {
        return current;
    }

or

    return current;   

so in my opinion your "if-else" is a conditional way to set the correct value for the variable "current" so using "else" for returning purposes is kind of strange,so you code can be refactored as this: use the if-else to catch all possible cases in the condition, set the variable in ever case and then, when you are done, return the value, like:

private AVLNode insert ( AVLNode current,int val)
{
    if ( current == null)
    {
        return new AVLNode(val, 0, null, null);
    }
    else if ( val < current.val)
    {
        current.left = insert ( current.left, val);
    }
    else if ( val > current.val)
    {
        current.right = insert ( current.right, val);
    }
         
    return current;     
}

The reason you get this error is because if you didn't have the final return statement, and ended up inside one of the if blocks, you'd never hit the else and therefore never hit a return statement.

Try stepping through the code with any case where current.val and val are both specified, but are two different values, for example current.val = 2 and val = 1.

In this case the execution will skip over the first if (because current is not null), and then go into the second if block (because val > current.val). Because one of the if conditions has been met, we will skip over the following else if and the else, and hit the final return statement. If that statement weren't there, we'd never return anything.

The reason this is different from the example you cite is because that example has a return in both the if and the else blocks, so whatever happens you always encounter a return statement. You could achieve the same by adding return current; inside both else if blocks, although it's far cleaner just to have the single return at the end.

Basically, if you have a collection of if...else if...else if...else the execution will only ever visit one of the blocks. Whichever path through the code gets executed must always have a return.

One of the principle of Clean code is method should have only one return statement so even if your code is good and working you could do it would be better if you do something like this

private AVLNode insert ( AVLNode current,int val)
    {
       AVLNode returningObject = current;

        if ( current == null) {
            current = new AVLNode(val, 0, null, null);
        } else if ( val < current.val) {
            current.left = insert ( current.left, val);
        } else if ( val > current.val) {
            current.right = insert ( current.right, val);
        }
   
        return returningObject ;       
    }

And that solve the issue with // I don't want to return you ////

But you problem appears cause Java is smart enough to check all your statements before you run your code, and if you put all your returns into block statements Java knows that there is situation where your statements can be not achieved and force you to always return something from the method.

This is the simplest way I can explain it.

All of your recursive calls to insert () sooner or later end up on one of the branches which contain a return (or let's assume that for the sake of the discussion).
I think that your misconception is that this is enough.
But each level of recursive call has to get its own return.

So these two lines

current.left = insert ( current.left, val);
/* ... */
current.right = insert ( current.right, val);

each also need a return, in order to return from the level which did the calling, the implied return at the deepest nested recursive call level is only for that level.

And not just for Java, either. When you have a nested structure like the one in the OP, when it matches the first 'if' and starts down your nested if-then-else-if ladder, then it is never going to somehow fall through to the 'else' that matches the top-level 'if' statement because it has already evaluated that condition and chosen its execution path.

The conditions you are testing for are independent and unconnected, so there is no need for the else construct at all. Once we have dealt with the null case and returned a new AVLNode, they are just simple unconnected if statements that conditionally modify the state of current.

private AVLNode insert ( AVLNode current, int val) {

   if (current == null) {
      return new AVLNode(val, 0, null, null);
   }

   if (val < current.val) {
      current.left = insert(current.left, val);
   }

   if (val > current.val) {
      current.right = insert(current.right, val);
   }

   // nothing changes when val == current.val, is this correct?

   return current;      
}