Java final Keyword
Usage and Examples

final Keyword in Java

In Java, the final keyword is a powerful modifier that brings immutability and restriction to your code. It's used to signal that something should not be changed — whether it’s a variable, a method, or even an entire class. Think of it as Java’s way of saying: "Hands off!"

1. Final Variables – Making Data Immutable

When you declare a variable as final, you are telling Java: “This variable’s value should be assigned only once.” Once a final variable is assigned, it cannot be modified again.

public class FinalVariableExample {
  public static void main(String[] args) {
    final int speedLimit = 60;
    System.out.println("Speed Limit: " + speedLimit);

    // speedLimit = 80; // Uncommenting this will cause a compile-time error
  }
}

Speed Limit: 60

Explanation: The variable speedLimit is marked as final. Attempting to change its value results in a compilation error. This is especially useful for constants or values you want to protect from accidental changes.

2. Final with Reference Types

With objects, final prevents reassignment — but does not make the object immutable.

class Car {
  String model = "Honda";
}

public class FinalReferenceExample {
  public static void main(String[] args) {
    final Car myCar = new Car();
    myCar.model = "Toyota"; // Allowed
    // myCar = new Car(); // Not allowed
    System.out.println("Car model: " + myCar.model);
  }
}

Car model: Toyota

Explanation: The reference myCar is final, so it cannot point to another Car object. However, the contents of the object (like its model) can still be changed.

3. Final Methods – Locking Down Behavior

When you mark a method as final, it cannot be overridden by subclasses. This ensures that the core logic of the method remains untouched — ideal for methods that form the backbone of a class’s behavior.

class Parent {
  final void show() {
    System.out.println("Final method in Parent");
  }
}

class Child extends Parent {
  // void show() { System.out.println("Trying to override"); } // Error!
}

Final method in Parent

Explanation: The method show() is declared final in the parent class, so any attempt to override it in a child class will lead to a compile-time error.

4. Final Classes – Preventing Inheritance

A final class is the ultimate boundary — it cannot be extended or subclassed. This is commonly seen in utility or security-related classes.

final class Vehicle {
  void drive() {
    System.out.println("Driving safely...");
  }
}

// class Bike extends Vehicle {} // Compile-time error

Driving safely...

Explanation: Once a class is marked final, it’s sealed. It can still be instantiated, but no subclassing is allowed — this ensures the class's design is preserved as-is.

5. Final Parameters – Read-Only Inputs

You can also declare method parameters as final to ensure that their values are not reassigned within the method.

public class FinalParameterExample {
  void display(final int x) {
    System.out.println("Value: " + x);
    // x = 50; // Not allowed
  }
}

Value: [whatever value is passed]

Explanation: This is useful for making sure that parameters passed to methods remain consistent, especially in recursive logic or callback scenarios.

When to Use final

• To define constants (e.g., final double PI = 3.14;)
• To avoid accidental modification of variables
• To ensure method behavior is locked for subclasses
• To improve code clarity and intent
• To make classes immutable and non-inheritable