How to correctly exit from a method (having return type 'int') without actually returning any value at all in Java?

Below is a code I encountered when implementing a Stack using LinkedList. The coding might seem incorrect and illegible. However, the question is outside the topic and the snippet only supplies a context.

1.   public int pop() {
2. 	     int x;
3. 	     if (len==0){
4. 		     System.out.println("Already empty.");
5. 		     return;	//Says this method must return a result of type int?
6. 	     }
7. 	
8. 	     int x = myLinkedList.deleteFromBegin();//this function returns the deleted integer
9. 	     --len;
10.      return x;
11.	 }

The above code is lacking a formal way of exiting from a method. The return statement at line 5 wants to return no value under a special condition. But normally the function needs to return an int showing the number just popped out.

pop seems to return the head of your list and then remove it from the list. Then how to handle the case of an empty list fully depend of the type of API you want.

Fail fast

throw new RuntimeException("Empty list"); 

If you detect you cannot pop, because the list is empty, you throw an exception. This way you can keep int type for your method signature. The consequence is that before calling pop, you'd expect one to be sure the list is not empty and can provide a function like isEmpty() or length() so that the caller can check on his side. You basically consider calling pop on an empty list to be an error.

Return a special value if the list is empty.

return -1;

This is dangerous and to be avoided. Your implementation is now depending of that value not being used for other meaning. if you use -1 for example but the client code want to legitimately add the number -1 to that list, you can't differentiate an empty list from a header element that happen to be -1.

Wrap the type to correctly represent that concept.

return null;
// or
return Optional.empty();

Either use the object type for integers (Integer) and use "null" as your special value. Or use Optional<Integer> and the bundled method isPresent() of that type.

Please notice that the effort is as high on the caller. He has to check for null or isPresent().

Conclusion

Personally I prefer the exception case, as it doesn't make sense to pop an empty list and I want that to fail properly. It also fail fast and a log give me the exact context where it failed. A null/optional or default int value relies on the client performing the proper logging/exception handling and they may forget to do it.

There is a defined Exception for this: https://docs.oracle.com/javase/10/docs/api/java/util/EmptyStackException.html that https://docs.oracle.com/javase/10/docs/api/java/util/Stack.html#pop() uses.

That way you can "return" without an int. In all other cases you need to supply an int which might be contents of the stack so you won't know if it is an empty stack or actual content unless you always check length before popping.

If you are allowed to change the signature, you can change return type to Optional<Integer> and return Optional.empty() and Optional.of(x) for the other cases.

If your return type is int then wherever you write return - you also should return a valid integer value.

Approach 1: Throw an exception:

There is another option to exit the method without returning - to throw an exception JavaDoc:

3.       if (len==0){
4.           System.out.println("Already empty.");
5.           throw new Exception("Already empty");  // or new RuntimeException(). or any other exception.
6.       }

Approach 2: Return Optional

If you want to segregate case when you return int or nothing, you could change return type from int to Optional<Integer> JavaDoc

1.   public Optional<Integer> pop() {
2.       int x;
3.       if (len==0){
4.           System.out.println("Already empty.");
5.           return Optional.empty();    //Says this method must return a result of type int?
6.       }
7.  
8.       int x = myLinkedList.deleteFromBegin();//this function returns the deleted integer
9.       --len;
10.      return Optional.of(x);
11.  }

in this case you will need to check for empty wherever this method is called:

Optional<Integer> x = pop();
if (x.isPresent()){
    x.get() // process returned value.
}