- unreachable statements (j14.19)
- compile-time restrictions on casts from interface to interface (j5.5)
- definite assignment (j16)
- volatile (j8.3.1.4)
- synchronized (j14.17)

--

(j8.1.2.1) It is a compile-time error to declare an abstract class
type such that it is not possible to create a subclass that implements
all of its abstract methods. This situation can occur if the class
would have as members two abstract methods that have the same method
signature (§8.4.2) but different return types. As an example, the
declarations:


interface Colorable { void setColor(int color); }

abstract class Colored implements Colorable {
        abstract int setColor(int color);
}

result in a compile-time error: it would be impossible for any
subclass of class Colored to provide an implementation of a method
named setColor, taking one argument of type int, that can satisfy both
abstract method specifications, because the one in interface Colorable
requires the same method to return no value, while the one in class
Colored requires the same method to return a value of type int
(§8.4).

--

doesn't report error for overloading conflicts between unimplemented
interface methods and class methods (must be required somewhere?)

--

forward uses of fields in field initialisers are not forbidden:

A compile-time error occurs if an initialization expression for a
class variable contains a use by a simple name of that class variable
or of another class variable whose declaration occurs to its right
(that is, textually later) in the same class.

A compile-time error occurs if an initialization expression for an
instance variable contains a use by a simple name of that instance
variable or of another instance variable whose declaration occurs to
its right (that is, textually later) in the same class.

The static initializers and class variable initializers are executed
in textual order and may not refer to class variables declared in the
class whose declarations appear textually after the use, even though
these class variables are in scope. This restriction is designed to
catch, at compile time, circular or otherwise malformed
initializations.

A compile-time error occurs if an initialization expression for an
interface field contains a reference by simple name to the same field
or to another field whose declaration occurs textually later in the
same interface.