Objects, Classes, and Interfaces |
Final Classes
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: security reasons and design reasons.Security: One mechanism that hackers use to subvert systems is to create subclasses 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 prevent any subclasses from being created. The
String
class in the java.lang package is a final class for just this reason. TheString
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 aString
they get exactly ajava.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 will print an error message and refuse to compile your program. In addition, the bytecode verifier ensures that the subversion is not taking place at the bytecode level by checking to make sure that a class is not a subclass of a final class.
Design: Another reason you may wish to declare a class as final are 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 a final class, use the keyword
final
before theclass
keyword in your class declaration. For example, if you wanted to declare your (perfect)ChessAlgorithm
class as final, its declaration would look like this:Any subsequent attempts to subclassfinal class ChessAlgorithm { . . . }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 errorFinal Methods
If creating a final class seems heavy handed for your needs, and you really just want to protect some of your class's methods from being overriden, you can use thefinal
keyword in a method declaration to indicate to the compiler that the method cannot be overridden by subclasses.You might wish to make a method final if the method has an implementation that should not be changed and is critical to the consistent state of the object. For example, instead of making your
ChessAlgorithm
class final, you might just want to make thenextMove
method final:class ChessAlgorithm { . . . final void nextMove(ChessPiece pieceMoved, BoardLocation newLocation) { } . . . }
Objects, Classes, and Interfaces |