It's better to be a little more precise. When you declare a checked exception in a method (via a throws clause,) then any code that calls that method must either handle that potential exception, or declare it itself (via a compatible throws clause.) By compatible I mean that it must declare that it throws that exception, or any supertype of that exception.
Now, assume that you have class A with a method() that declares that it throws ExceptionA (where ExceptionA is checked.) Now imagine a subclass of A, let's call it B. If B overrides method(), it is not required to declare any exceptions at all. But it can not declare broader checked exceptions (or checked exceptions that do not pass the Is-A
test for the declared exceptions in the method of the superclass) than the ones declared by method(). In our case, B.method() could declare checked exceptions that are either ExceptionA, or subtypes of ExceptionA.
Why is that so? Because checked exceptions are checked by the compiler (the compiler must verify that you either declare or catch any checked exceptions that may be thrown by your code.) Now, the compiler doesn't think polymorphically, it only looks at the declared type of a reference. So if you allowed B.method() to throw, say ExceptionX (where ExceptionX is a checked exception that is not a subclass of ExceptionA) and you did this:
A b = new B();
try {
b.method();
}
catch (ExceptionA ea) {
}
At this point, the compiler would see that you are calling method() on a reference of type A, which may throw ExceptionA exceptions. It would say: OK, you are handling a potential exception of type ExceptionA.
But what if B.method() (the method that is called polymorphically at runtime) actually throws ExceptionX? Then your code would not handle that and it would fail.
That's why you can't throw broader checked exceptions (or any checked exceptions that are not subtypes of the exceptions declared in the overridden method.) Because the compiler is limited to verify handling/declaration of exceptions based on the type of references.