Can We Extend Final Method in Java?

Java Final Methods

The final keyword in Java can be used to prohibit method overriding, declare constants, and stop inheritance. A method that is marked as final indicates that subclasses are not allowed to override it. It can be very helpful in a number of situations, including:

Ensuring Security and Integrity: In certain situations, you may want to make sure that subclasses are unable to change a method's implementation and that it stays consistent. Applications that are security-sensitive frequently do this.
Performance Optimisation: Since the Java compiler is aware that a final method would not be overridden, it can optimise it more effectively than a non-final method. In some cases, this can result in better performance.

Declaring a Final Method

A final method is declared using the final keyword before the method's return type. Here is an example:

 
public class ParentClass {
    public final void displayMessage() {
        System.out.println("This is a final method.");
    }
}   

In the above example, the displayMessage method is declared as final in the ParentClass. This means that any subclass of ParentClass will not be able to override this method.

Attempting to Override a Final Method

If we attempt to override a final method in a subclass, the Java compiler will generate an error. Here is an example to illustrate this:

 
public class ChildClass extends ParentClass {
    // Attempting to override the final method will result in a compilation error
    @Override
    public void displayMessage() {
        System.out.println("Trying to override a final method.");
    }
}   

Output:

To provide a comprehensive understanding, let's look at a practical example involving a parent class with a final method and a subclass attempting to override it.

File Name: ChildClass.java

 
public class ParentClass {
    public final void showDetails() {
        System.out.println("Details from the ParentClass.");
    }
    public void showMessage() {
        System.out.println("Message from the ParentClass.");
    }
}
public class ChildClass extends ParentClass {
    // This will cause a compilation error because showDetails is final in the parent class
    /*
    @Override
    public void showDetails() {
        System.out.println("Details from the ChildClass.");
    }
    */
    // This is allowed because showMessage is not final in the parent class
    @Override
    public void showMessage() {
        System.out.println("Message from the ChildClass.");
    }
    public static void main(String[] args) {
        ChildClass child = new ChildClass();
        child.showDetails(); // Calls the final method from ParentClass
        child.showMessage(); // Calls the overridden method from ChildClass
    }
}   

Output:

 
Details from the ParentClass.
Message from the ChildClass.

In this example, the showDetails() method in the ParentClass is declared as final, preventing the ChildClass from overriding it. However, the showMessage() method is not final, allowing the ChildClass to provide its own implementation.

Conclusion

A final method in Java is one that subclasses are unable to override. It can help to preserve the integrity and security of the method's behaviour by guaranteeing that the implementation of the method stays unaltered. A compilation error will occur ifwe try to override a final method. Developers may construct their Java classes and methods more intelligently if they comprehend the purpose of final methods.

Next TopicCheck-if-the-given-two-matrices-are-mirror-images-of-one-another-in-java

← prev next →