The Java Language Specification, Third Edition

CLASSES Member Type Declarations 8.5
This example results in a compile-time error, because the override of method
move in class CheckedPoint declares that it will throw a checked exception that
the move in class Point has not declared. If this were not considered an error, an
invoker of the method move on a reference of type Point could find the contract
between it and Point broken if this exception were thrown.
Removing the throws clause does not help:
class CheckedPoint extends Point {
void move(int dx, int dy) {
if ((x + dx) < 0 || (y + dy) < 0)
throw new BadPointException();
x += dx; y += dy;
}
}
A different compile-time error now occurs, because the body of the method
move cannot throw a checked exception, namely BadPointException, that does
not appear in the throws clause for move.
8.5 Member Type Declarations
A member class is a class whose declaration is directly enclosed in another class
or interface declaration. Similarly, a member interface is an interface whose declaration
is directly enclosed in another class or interface declaration. The scope
(§6.3) of a member class or interface is specified in §8.1.6.
If the class declares a member type with a certain name, then the declaration
of that type is said to hide any and all accessible declarations of member types
with the same name in superclasses and superinterfaces of the class.
Within a class C, a declaration d of a member type named n shadows the declarations
of any other types named n that are in scope at the point where d occurs.
If a member class or interface declared with simple name C is directly
enclosed within the declaration of a class with fully qualified name N, then the
member class or interface has the fully qualified name N.C. A class inherits from
its direct superclass and direct superinterfaces all the non-private member types of
the superclass and superinterfaces that are both accessible to code in the class and
not hidden by a declaration in the class.
A class may inherit two or more type declarations with the same name, either
from two interfaces or from its superclass and an interface. A compile-time error
occurs on any attempt to refer to any ambiguously inherited class or interface by
its simple name
DRAFT
237