final (Java)

In the Java programming language, the final keyword is used in several contexts to define an entity that can only be assigned once.

Once a final variable has been assigned, it is intended to always contain the same value. If a final variable holds a reference to an object, then the state of the object may be changed by operations on the object, but the variable will always refer to the same object (this property of final is called non-transitivity^[1]). This applies also to arrays, because arrays are objects; if a final variable holds a reference to an array, then the components of the array may be changed by operations on the array, but the variable will always refer to the same array.^[2]

Final classes

A final class cannot be subclassed. As doing this can confer security and efficiency benefits, many of the Java standard library classes are final, such as java.lang.System and java.lang.String.

Example:

final class Final {
    // ...
}

// Forbidden
class Derived extends Final {
    // ...
}

Final methods

A final method cannot be overridden or hidden by subclasses.^[3] 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.^[4]

Example:

public class Base {
    public void foo() {
        // ...
    }

    public final void bar() {
        // ...
    }

    public static void baz() { 
        // ...
    }

    public static final void qux() {
        // ...
    }
}

public class Derived extends Base {
    // OK, overriding Base::foo()
    @Override
    public void foo() {
        // ...
    }

    // forbidden
    @Override
    public void bar() {
        // ...
    }

    // OK, overriding Base::baz()
    @Override
    public static void baz() {
        // ...
    }

    // forbidden
    @Override
    public static void qux() {
        // ...
    }
}

A common misconception is that declaring a method as final improves efficiency by allowing the compiler to directly insert the method wherever it is called (see inline expansion). Because the method is loaded at runtime, compilers are unable to do this. Only the runtime environment and JIT compiler know exactly which classes have been loaded, and so only they are able to make decisions about when to inline, whether or not the method is final.^[5]

Machine code compilers that generate directly executable, platform-specific machine code, are an exception. When using static linking, the compiler can safely assume that methods and variables computable at compile-time may be inlined.

Final variables

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 in 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.^[6] (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 constants in all uppercase, using underscore to separate words.^[7]

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 result in 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, the use of final 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.

Though it appears to violate the final principle, the following is a legal statement:

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

Since the obj variable goes out of scope with each iteration of the loop, it is actually redeclared each iteration, allowing the same token (i.e. obj) to be used to represent multiple variables.^[8]

import java.awt.Point;

public class FinalDemo {

    static class CoordinateSystem {
        private final Point ORIGIN = new Point(0, 0);

        public Point getOrigin() {
            return ORIGIN;
        }
    }

    public static void main(String[] args) {
        CoordinateSystem coordinateSystem = new CoordinateSystem();

        coordinateSystem.getOrigin().x = 15;

        assert coordinateSystem.getOrigin().getX() == 0;
    }
}

package org.wikipedia.examples;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.SwingUtilities;

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);
            }
        });
    }
}

final boolean hasTwoDigits;
if (number >= 10 && number < 100) {
    hasTwoDigits = true;
}
if (number > -100 && number <= -10) {
    // compile-error because the final variable might already be assigned.
    hasTwoDigits = true;
}

final boolean isEven;

if (number % 2 == 0) {
    isEven = true;
}

// compile-error because the variable was not assigned in the else-case.
System.out.println(isEven);

boolean isEven; // NOT final

if (number % 2 == 0) {
    isEven = true;
}

// Same compile-error because the non-final variable was not assigned in the else-case.
System.out.println(isEven);

Reflection

Despite initialized final fields being intended to be immutable, they actually can be changed through reflection. The java.lang.reflect package contains methods that can make any field accessible and change them. As of 2026, there are plans to remove this ability in a future version of Java.^[12]

C/C++ analog of final variables

In C and C++, the analogous construct is the const keyword. This differs substantially from final in Java, most basically in being a type qualifier: const is part of the type, not only part of the identifier (variable). This also means that the constancy of a value can be changed by casting (explicit type conversion), in this case known as "const casting". Nonetheless, casting away constness and then modifying the object results in undefined behavior if the object was originally declared const. Java's final is a strict rule such that it is impossible to compile code that directly breaks or bypasses the final restrictions. Using reflection, however, it is often possible to still modify final variables. This feature is mostly made use of when deserializing objects with final members.

Further, because C and C++ expose pointers and references directly, there is a distinction between whether the pointer itself is constant, and whether the data pointed to by the pointer is constant. Applying const to a pointer itself, as in SomeClass* const ptr, means that the contents being referenced can be modified, but the reference itself cannot (without casting). This usage results in behaviour which mimics the behaviour of a final variable reference in Java. By contrast, when applying const to the referenced data only, as in const SomeClass* ptr, the contents cannot be modified (without casting), but the reference itself can. Both the reference and the contents being referenced can be declared as const.

In C++, the final keyword is used to denote that a function cannot be further overridden. It is also used similarly to Java to declare a class as final (cannot be extended).

// final in a class declaration declares that a class cannot be extended
class Z final : public X, public Y {
public:
    // final in a method signature declares that a method cannot be overridden further
    void someOperation() override final {
        // do something here
    }
};

C# analogs for final keyword

C# can be considered as similar to Java, in terms of its language features and basic syntax: Java has JVM, C# has .Net Framework; Java has bytecode, C# has CIL; Java has no pointers (real memory) support, C# is the same.

Regarding the final keyword, C# has two related keywords:

1. The equivalent keyword for methods and classes is sealed
2. The equivalent keyword for variables is readonly ^[13]

Note that a key difference between the C/C++ derived keyword const and the C# keyword readonly is that const is evaluated at compile time, while readonly is evaluated at runtime, and thus can have an expression that is only calculated and fixed later (at runtime).

See also

• final (C++)

References