The JavaTM Tutorial

| Start of Tutorial > Start of Trail > Start of Lesson | Search Feedback Form

Trail: Learning the Java Language
Lesson: Classes, Interfaces, and Packages

## Writing Final Classes and Methods

> You can declare that your class is final, that is, that your class cannot be subclassed. There are (at least) two reasons why you might want to do this: to increase system security by preventing system subversion, and for reasons of good object-oriented design.

> Security:

> > One mechanism that hackers use to subvert systems is to create a subclass of a class and then substitute their class for the original. The subclass looks and feels like the original class but does vastly different things, possibly causing damage or getting into private information. To prevent this kind of subversion, you can declare your class to be final and thereby prevent any subclasses from being created. The `String` class in the `java.lang` package is a final class for just this reason. This class is so vital to the operation of the compiler and the interpreter that the Java system must guarantee that whenever a method or object uses a `String` it gets exactly a `java.lang.String` and not some other string. This ensures that all strings have no strange, inconsistent, undesirable, or unpredictable properties.

> > If you try to compile a subclass of a final class, the compiler prints an error message and refuses to compile your program. In addition, the bytecode verifier ensures that the subversion is not taking place at the bytecode level. It does this by checking to make sure that a class is not a subclass of a final class.

> Design:

> > You may also wish to declare a class as final for object-oriented design reasons. You may think that your class is "perfect" or that, conceptually, your class should have no subclasses.

> To specify that your class is final, use the keyword `final` before the `class` keyword in your class declaration.

> For example, if you wanted to declare your (perfect) `ChessAlgorithm` class as final, its declaration should look like this:

> >     final class ChessAlgorithm {
> >         . . .
> >     }

> Any subsequent attempts to subclass `ChessAlgorithm` will result in a compiler error such as the following:

> >     Chess.java:6: Can't subclass final classes: class ChessAlgorithm
> >     class BetterChessAlgorithm extends ChessAlgorithm {
> >           ^
> >     1 error

### Final Methods

> Does creating a final class seem heavy-handed for your needs? Do you really just want to protect some of your class's methods from being overridden? You can use the `final` keyword in a method declaration to indicate to the compiler that the method cannot be overridden by subclasses. As just shown, the `Object` class does this; some of its methods are final and some are not.

> You might wish to make a method final if it has an implementation that should not be changed and it is critical to the consistent state of the object. For example, instead of making your `ChessAlgorithm` class final, you might want instead to make the `nextMove` method final:

> >     class ChessAlgorithm {
> >         . . .
> >         final void nextMove(ChessPiece pieceMoved,
> >                             BoardLocation newLocation)
> >         {
> >             ...
> >         }
> >         . . .
> >     }

| Start of Tutorial > Start of Trail > Start of Lesson | Search Feedback Form