A class declaration may include class modifiers.
ClassModifiers:
ClassModifier
ClassModifiersClassModifier ClassModifier: one of
public
abstract final
The access modifier public
is discussed in §6.6. A compile-time error occurs if
the same modifier appears more than once in a class declaration. If two or more
class modifiers appear in a class declaration, then it is customary, though not
required, that they appear in the order consistent with that shown above in the production for ClassModifier.
An abstract
class is a class that is incomplete, or to be considered incomplete.
Only abstract
classes may have abstract
methods (§8.4.3.1, §9.4), that is,
methods that are declared but not yet implemented. If a class that is not abstract
contains an abstract
method, then a compile-time error occurs. A class has
abstract
methods if any of the following is true:
abstract
method (§8.4.3).
abstract
method from its direct superclass (§8.1.3).
abstract
) and the class neither declares nor inherits a method that implements it.
abstract class Point { int x = 1, y = 1; void move(int dx, int dy) { x += dx; y += dy; alert(); } abstract void alert(); }
abstract class ColoredPoint extends Point { int color; }
class SimplePoint extends Point { void alert() { } }
a class Point
is declared that must be declared abstract
, because it contains a
declaration of an abstract
method named alert
. The subclass of Point
named
ColoredPoint
inherits the abstract
method alert
, so it must also be declared
abstract
. On the other hand, the subclass of Point
named SimplePoint
provides an implementation of alert
, so it need not be abstract
.
A compile-time error occurs if an attempt is made to create an instance of an abstract
class using a class instance creation expression (§15.8). An attempt to instantiate an abstract
class using the newInstance
method of class Class
(§20.3.6) will cause an InstantiationException
(§11.5.1) to be thrown. Thus, continuing the example just shown, the statement:
Point p = new Point();
would result in a compile-time error; the class Point
cannot be instantiated
because it is abstract
. However, a Point
variable could correctly be initialized
with a reference to any subclass of Point
, and the class SimplePoint
is not
abstract
, so the statement:
Point p = new SimplePoint();
A subclass of an abstract
class that is not itself abstract
may be instantiated, resulting in the execution of a constructor for the abstract
class and, therefore, the execution of the field initializers for instance variables of that class. Thus, in the example just given, instantiation of a SimplePoint
causes the default constructor and field initializers for x
and y
of Point
to be executed.
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).
A class type should be declared abstract
only if the intent is that subclasses can be created to complete the implementation. If the intent is simply to prevent instantiation of a class, the proper way to express this is to declare a constructor (§8.6.8) of no arguments, make it private
, never invoke it, and declare no other constructors. A class of this form usually contains class methods and variables. The class java.lang.Math
is an example of a class that cannot be instantiated; its declaration looks like this:
public final class Math {
private Math() { } // never instantiate this class
declarations of class variables and methods
}
A class can be declared final
if its definition is complete and no subclasses are
desired or required. A compile-time error occurs if the name of a final
class
appears in the extends
clause (§8.1.3) of another class
declaration; this implies
that a final
class cannot have any subclasses. A compile-time error occurs if a
class is declared both final
and abstract
, because the implementation of such a
class could never be completed (§8.1.2.1).
Because a final
class never has any subclasses, the methods of a final
class are never overridden (§8.4.6.1).