Callable: why can we "change" the exception on implementation?

Question

This code compiles without an error:

private FutureTask<MessageSource> loadingTask(final Locale locale)
{
    return new FutureTask<MessageSource>(new Callable<MessageSource>()
    {
        @Override
        public MessageSource call()
            throws IOException
        {
            return loader.load(locale);
        }
    });
}

But the Callable interface defines this:

public V call()
    throws Exception;

How come I can declare that my override throws IOException?

Note: I have already seen, and exploited that, with Guava's CacheLoader for instance.

http://stackoverflow.com/questions/5875414/method-overriding-and-exceptions — assylias, Jun 06 '13 at 09:17

score 4 · Answer 1 · answered Jun 06 '13 at 09:20

The short answer: you can do that because an IOException is-a Exception.

public V call() throws Exception

means "this method can throw an Exception and no other checked exception!".

If you now override this method like this:

public MessageSource call() throws IOException

You're effectively saying "we would be allowed to throw any Exception but we voluntary restrict ourself to just a subset: IOException and its children".

You could even do this:

public Something call()

with no throws at all: "we would be allowed to throw any Exception, but I promise that we throw no checked exceptions at all!"

score 2 · Answer 2 · answered Jun 06 '13 at 09:20

When overriding a method that throws some exceptions, the overriden method must throw the same exceptions as the overriding method or some of their superclasses.

This is described in the JLS #8.4.8.3:

suppose that B is a class or interface, and A is a superclass or superinterface of B, and a method declaration n in B overrides or hides a method declaration m in A. Then:

If n has a throws clause that mentions any checked exception types, then m must have a throws clause, or a compile-time error occurs.

For every checked exception type listed in the throws clause of n, that same exception class or one of its supertypes must occur in the erasureof the throws clause of m; otherwise, a compile-time error occurs.

(where n overrides m)

Callable: why can we "change" the exception on implementation?

2 Answers2