函数抛出异常时的返回类型可以是Exception

Question

Let's say I have a function

private RuntimeException foo() {
    return new RuntimeException();
}

and exception there is not thrown and it can be processed like

throw foo();

or return value can be assigned to a variable

RuntimeException e = foo();

But the function can be changed to

private RuntimeException foo() {
    throw new RuntimeException();
}

and it still compiles and can be used like in previous examples or can just be called like foo(); and Exception will be thrown.

But why is it possible to specify RuntimeException as a return type of a method that doesn't return it but throws it instead. Is there any connection between throw and return behavior in this case?

I've noticed that having Exception (or more generally Throwable ) return type ensures that it will be thrown/returned in every decision branch like if/else statements. But is there any more practical usage or recommended of this?

Answer 1

Since throw will make the execution of the method stop immediately and control is passed back to the caller, it doesn't matter what your method returns. No matter what type you return, that type will not be returned, because you are throwing an exception (which indicates something wrong happened) on the first line.

The compiler allows this because throwing an exception means something wrong happened, like the arguments are invalid, or the argument is null, and so on. In such error conditions, the compiler does not expect the method to return a value normally. It makes sense because obviously when something wrong happens, the method can't compute whatever it is that it was going to compute.

So the phrase "all code paths must return a value" should really say "all code paths must return a value or throw a Throwable ".

Answer 2

There is no relation between what a method returns and what it can throw. and there are use cases where a method may both return and throw an exception.

consider the following scenario: a method that is called to produce an application-specific exception:

public Exception produceException(User u) {
    if (u.id == null) return new UserNotFoundException();
    if (u.name == null) return new UserDidNotCompleteRegistrationException();
    if (u.email == null) return new UserDidNotVerifyEmailException();
}

now guess what will happen if the argument itself is null ? and the method does not even declares a throws clause...

now, regarding having Exception as return value for the sake of ensuring that an exception is returned at every branch is just bad design. return value is not the mechanism to be used for throwing exception. if you surround the entire method body with try-catch you will catch all exceptions from all branches.

Answer 3

why is it possible to specify RuntimeException as a return type of a method that doesn't return it but throws it instead. Is there any connection between throw and return behavior in this case?

It's possible to specify any type as a return type of any method. There is no connection between return and throw behavior.

I've noticed that having Exception (or more generally Throwable) return type ensures that it will be thrown/returned in every decision branch like if/else statements

No, that's not the case. There is no way to "ensure [an Exception] will be thrown in every decision branch". The only thing you can do is to state "this method may throw an Exception by using the throws keyword:

public void mightThrowException() throws Exception {...}

but there's no guarantee that any exception will be thrown at all.

BTW, there are two types of exceptions: checked and unchecked. Unchecked exceptions are subclasses of RuntimeException ; those do not need to be declared for your method. Checked exceptions do, so

public void throwsIoException() {
    throw new IOException();
}

is illegal because IOException is a checked exception that needs to be declared with throws .

Answer 4

You mixed something up with your example. Because when throwing an exception in a method the return type is not really considered, so instead of declaring the method like in your example. you could also declare it like the following:

public void foo(){
    throw new RuntimeException();
}

or:

public MyComplexType foo2(){
    throw new RuntimeException();
}

The result is simply the same: An exception is thrown. The calling code just will look differently eg:

foo(); // throws RuntimeException
myOtherComputation(); // is never reached

or

MyComplexType type = foo2(); // throws RuntimeException
type.doSomething(); // is never reached

This behaviour can be useful when using for example a switch statement in a method but throwing an error when entering the default branch:

public String foo(String string){
    switch(string){
        case "foo":
             return "bar";
        case "bar":
             return "foo";
        default:
            throw new UnsupportedOperationException("Unknown string: '" + string + "'!");
     }
}