Question

Can a method in a subclass override a method in the parent class and throw a run time exception when the method in the parent class throws no exception? Something like this:

class X { public void foo() { System.out.print("X "); } }

public class SubB extends X {
    public void foo() throws RuntimeException {
        super.foo();
        if (true) 
            throw new RuntimeException();
        System.out.print("B ");
    }

    public static void main(String[] args) {
        new SubB().foo();
    }
}

Answer 1

Yes, because runtime exceptions aren’t part of the method signature. (You can add them but the compiler doesn’t care, they’re just documentation.)

I think the rationale is that RuntimeExceptions are usually programmer errors, like NPEs or going out of bounds of an array, so it doesn’t make sense to try to restrict them the way that checked exceptions are restricted. You can’t make a rule saying, this method (and any method overriding it) can never ever throw a NullPointerException, because the JVM doesn’t make those kinds of guarantees.

In the Java Language Specification under Compile-Time Checking of Exceptions it says:

The unchecked exception classes (§11.1.1) are exempted from
compile-time checking.

Of the unchecked exception classes, error classes are exempted because
they can occur at many points in the program and recovery from them is
difficult or impossible. A program declaring such exceptions would be
cluttered, pointlessly. Sophisticated programs may yet wish to catch
and attempt to recover from some of these conditions.

Of the unchecked exception classes, runtime exception classes are
exempted because, in the judgment of the designers of the Java
programming language, having to declare such exceptions would not aid
significantly in establishing the correctness of programs. Many of the
operations and constructs of the Java programming language can result
in exceptions at run-time. The information available to a Java
compiler, and the level of analysis a compiler performs, are usually
not sufficient to establish that such run-time exceptions cannot
occur, even though this may be obvious to the programmer. Requiring
such exception classes to be declared would simply be an irritation to
programmers.

For example, certain code might implement a circular data structure
that, by construction, can never involve null references; the
programmer can then be certain that a NullPointerException cannot
occur, but it would be difficult for a Java compiler to prove it. The
theorem-proving technology that is needed to establish such global
properties of data structures is beyond the scope of this
specification.