In the Java programming language, the final keyword is used in several different contexts to define an entity which cannot later be changed.

Final classes [edit]

A final class cannot be subclassed. This is done for reasons of security and efficiency. Accordingly, many of the Java standard library classes are final, for example java.lang.System and java.lang.String. All methods in a final class are implicitly final.

Example:

public final class MyFinalClass {...}
 
public class ThisIsWrong extends MyFinalClass {...} // forbidden

Restricted subclasses are often referred to as "soft final" classes.^[1]

Final methods [edit]

A final method cannot be overridden by subclasses. This is used to prevent unexpected behavior from a subclass altering a method that may be crucial to the function or consistency of the class.^[2]

Example:

public class MyClass {
    public void myMethod() {...}
    public final void myFinalMethod() {...}
}
 
public class AnotherClass  extends MyClass {
    public void myMethod() {...}            // Ok
    public final void myFinalMethod() {...} // forbidden  
}

A common misconception is that declaring a class or method final improves efficiency by allowing the compiler to directly insert the method inline wherever it is called. In fact the compiler is unable to do this because the method is loaded at runtime and might not be the same version as the one that was just compiled. Only the runtime environment and JIT compiler have the information about exactly which classes have been loaded, and are able to make better decisions about when to inline, whether or not the method is final.^[3]

An exception to this are machine code compilers (those who build directly executable, platform specific machine code). In this case, when using static linking, the compiler can safely assume that the methods, and also compiletime-computable variables, can be inlined.

Final variables [edit]

A final variable can only be initialized once, either via an initializer or an assignment statement. It does not need to be initialized at the point of declaration: this is called a "blank final" variable. A blank final instance variable of a class must be definitely assigned at the end of every constructor of the class in which it is declared; similarly, a blank final static variable must be definitely assigned in a static initializer of the class in which it is declared; otherwise, a compile-time error occurs in both cases.^[4] (Note: If the variable is a reference, this means that the variable cannot be re-bound to reference another object. But the object that it references is still mutable, if it was originally mutable.)

Unlike the value of a constant, the value of a final variable is not necessarily known at compile time. It is considered good practice to represent final primitive type variables in all uppercase, using underscore to separate words.^[5]

Example:

public class Sphere {
 
    // pi is a universal constant, about as constant as anything can be.
    public static final double PI = 3.141592653589793;  
 
    public final double RADIUS;
    public final double XPOS;
    public final double YPOS;
    public final double ZPOS;
 
    Sphere(double x, double y, double z, double r) {
         RADIUS = r;
         XPOS = x;
         YPOS = y;
         ZPOS = z;
    }
 
    [...]
}

Any attempt to reassign RADIUS, XPOS, YPOS, or ZPOS will meet with a compile error. In fact, even if the constructor doesn't set a final variable, attempting to set it outside the constructor will result in a compilation error.

To illustrate that finality doesn't guarantee immutability: suppose we replace the three position variables with a single one:

    public final Position pos;

where pos is an object with three properties pos.x, pos.y and pos.z. Then pos cannot be assigned to, but the three properties can, unless they are final themselves.

Like full immutability, finality of variables has great advantages, especially in optimization. For instance, Sphere will probably have a function returning its volume; knowing that its radius is constant allows us to memoize the computed volume. If we have relatively few Spheres and we need their volumes very often, the performance gain might be substantial. Making the radius of a Sphere final informs developers and compilers that this sort of optimization is possible in all code that uses Spheres.

Final and inner classes [edit]

When an anonymous inner class is defined within the body of a method, all variables declared final in the scope of that method are accessible from within the inner class. Once it has been assigned, the value of the final variable cannot change. This allows the Java compiler to "capture" the value of the variable at run-time and store a copy as a field in the inner class. Once the outer method has terminated and its stack frame has been removed, the original variable is gone but the inner class's private copy persists in the class's own memory.

import javax.swing.*;
 
public class FooGUI {
 
    public static void main(String[] args) {
        //initialize GUI components
        final JFrame jf = new JFrame("Hello world!"); //allows jf to be accessed from inner class body
        jf.add(new JButton("Click me"));
 
        // pack and make visible on the Event-Dispatch Thread
        SwingUtilities.invokeLater(new Runnable() {
            @Override
            public void run() {
                jf.pack(); //this would be a compile-time error if jf were not final
                jf.setLocationRelativeTo(null);
                jf.setVisible(true);
            }
        });
    }
}

Blank final [edit]

The blank final, which was introduced in Java 1.1, is a final variable whose declaration lacks an initializer.^[6][7] A blank final can only be assigned once and must be unassigned when an assignment occurs. In order to do this, a Java compiler runs a flow analysis to ensure that, for every assignment to a blank final variable, the variable is definitely unassigned before the assignment; otherwise a compile-time error occurs.^[8]

In general, a Java compiler will ensure that the blank final is not used until it is assigned a value and that once assigned a value, the now final variable cannot be reassigned another value. However it is a misconception to think a final variable can itself not change, you simply cannot assign it more than once. For example, the following is a legal statement:

for (final SomeObject obj : someList) {
   // do something with obj
}

Since obj is only actually assigned in a single statement, it is legal even though obj will change with each iteration.^[9]

Difference from the C++ const type qualifier [edit]

The C++ parallel to Java's final would be a reference in that once it is initialized, the data being referenced can be changed, but the reference itself can not.

Another C++ parallel is SomeClass * const ptr where the contents being referenced can be modified, but the reference itself can not without casting. This is different from the C++ const SomeClass * ptr where the contents cannot be modified without casting, but the reference itself can.

C++ const is a soft guideline and it can easily be overridden by the programmer; the programmer can easily cast a const reference to an unconst reference. Java's final is a strict rule in that you can't write valid code that compiles that breaks or simply bypasses the final restrictions.

References [edit]

External links [edit]

• It's Time To Deprecate Final
• The Final Word On the final Keyword by Renaud Waldura