Final Methods

A school program needs reliable data and clear rules. A final instance method cannot be overridden by a subclass. It can preserve an important report rule while allowing other subclass behavior.

In Java, the keyword final with methods is used to preserve design integrity, prevent misuse, and encourage safe code extension. But what exactly does it mean to make a method final?

A final method is a method that cannot be overridden by subclasses. This ensures that the core behavior defined in the method remains consistent and unchangeable when inherited.

This is particularly useful when designing frameworks or libraries, where certain base functionalities should never be altered by child classes.

class Parent {
    final void show() {
        System.out.println("This is a final method.");
    }
}

Any class that extends Parent will inherit the method show(), but will not be allowed to override it.

• To prevent unexpected behavior from subclass overrides
• To ensure critical business logic is not changed
• To improve performance (some JVMs optimize final methods)

class Parent {
    final void display() {
        System.out.println("Display from Parent");
    }
}

class Child extends Parent {
    // Uncommenting below will cause a compile-time error
    // void display() {
    //     System.out.println("Display from Child");
    // }
}

Compile-time Error: Cannot override the final method from Parent

Explanation: The compiler blocks the attempt to override the display() method because it’s declared final in the parent class.

class Parent {
    final void greet() {
        System.out.println("Hello from Parent");
    }
}

class Child extends Parent {
    void welcome() {
        greet(); // Valid: calling inherited final method
    }
}

public class Main {
    public static void main(String[] args) {
        Child c = new Child();
        c.welcome();
    }
}

Hello from Parent

Though the method greet() is final and can’t be overridden, it can still be inherited and called like any other method.

Yes! Overloading is based on the method signature (name and parameters), not inheritance. So you can define methods with the same name but different parameter lists—even if one version is final.

class Example {
    final void test() {
        System.out.println("No parameters");
    }

    void test(int x) {
        System.out.println("One parameter: " + x);
    }
}

No parameters
One parameter: 42

The final keyword in methods is a safeguard. It’s used by developers who want to make sure the rules aren’t rewritten downstream. Use it wisely in scenarios where the base method's logic must be preserved across the inheritance chain.

• final methods cannot be overridden.
• You can still call and inherit final methods.
• Final methods can be overloaded.
• Use them when you want to lock down method behavior for reliability.

Final methods can still be called. Preventing overriding is different from preventing overloads with different parameters.

Before running this Java program, write down each line you expect to see. Identify the value, branch, object or exception responsible for each line. Then explain whether the following assumption is valid: Final methods can still be called.

Java 17 · Main.java · complete practice program

public class Main  {
  static class FixedReport  {
    final String label()  {
      return "Final report";
    }
  }
  public static void main(String[] args)  {
    System.out.println(new FixedReport().label());
  }
}

Java 17 · Main.java · source repeated for this answer

public class Main  {
  static class FixedReport  {
    final String label()  {
      return "Final report";
    }
  }
  public static void main(String[] args)  {
    System.out.println(new FixedReport().label());
  }
}

Expected output

Final report

A final instance method cannot be overridden by a subclass. It can preserve an important report rule while allowing other subclass behavior.

Final methods can still be called. Preventing overriding is different from preventing overloads with different parameters.

Run with javac Main.java, then java Main. The declaration inside Main keeps the helper type available to this standalone example.

A final instance method cannot be overridden by a subclass. It can preserve an important report rule while allowing other subclass behavior. Final methods can still be called. Preventing overriding is different from preventing overloads with different parameters.

Related explanations: Java Variables, Java If Statement - Syntax and Examples, Java Class - Blueprint of Objects, Exceptions in Java Introduction.

Supporting documentation: Official Java learning guide and Java 17 language specification.