Private and Final Methods in Java

Methods in Java play an important role in making the code more readable, support code reusability, and defining the behaviour of the objects. And we can also restrict the methods based on requirements using the keywords and modifiers such as final and private. These two have different, distinct purposes in controlling. In this article, we are covering the use cases and their significant differences.

Now, first see the key differences between private and final methods in Java.

Private vs Final Method

The private and final are both method modifiers, and they have different use cases, and their common differences are mentioned below:

Private Methods in Java

The private modifier in Java is used to restrict the access level if a method is marked with the private keyword, then it can only be accessed within the class in which it is defined and when a method is declared as private then it cannot be directly called from the outside of the class, not even by the child or subclass or other classes in the same package. It is very useful in many situations, such as providing the abstraction (showing the necessary details and hiding the implementation).

Important Characteristics of Private Methods:

• Restriction: Private methods are restricted from being called by other methods directly.
• Encapsulation: Private methods allow the implementation details to be hidden from other classes, which is useful for data hiding and provides security against unauthorised modification.
• Exposure Prevention: Private methods are used for internal operations, which are used for internal calculations or tasks that prevent exposing the internal calculation to other classes.

Note: If we try to directly access the private method from another class, then it will result in a compile-time error.

Example 1: Demonstration of Private Methods in Java

// Java program demonstrating the use of a private method
// and accessing it within the same class
class Geeks {
    
    // A private method
    private void sayHello() {
        System.out.println("This is a private method in the Geeks class.");
    }

    public static void main(String[] args) {
        
        // Object of Geeks class
        Geeks obj = new Geeks();

        // Accessing the private method 
        // within the same class
        obj.sayHello();
    }
}

This is a private method in the Geeks class.

Explanation: In the above example, we use the private method and call it from the same class by creating an object of the Geeks class, and it will print the message.

Example 2: Attempt to access the private method of another class.

// Java program demonstrating the use of a private method
// and accessing it within the same class
class Greet{
    
    // A private method
    private void sayHello() {
        System.out.println("This is a private method in the Geeks class.");
    }
}
public class Geeks {

    public static void main(String[] args) {
        Greet obj = new Greet();

        // Accessing the private method 
        // from another class
        obj.sayHello();
    }
}

Output:

Explanation: In the above example, we try to access the private method of another class, and it will throw a compile-time error as shown in the output image.

Final Methods in Java

If the method is declared using the final keyword in Java, then the method cannot be overridden by the child or subclass. It is useful when we want to restrict that the other class from modifying the behaviour of the method and prevent the method from altering critical functionality that should remain consistent across different subclasses.

Important Characteristics of Final Methods:

• Restrict Overriding: A final method cannot be overridden by any of the subclasses (child classes).
• Consistency: The final methods ensure that the method behaviour remains the same and unmodified.
• Prevent from Critical Operations: Final methods are useful for preventing the critical methods modification where overriding can result in undefined behaviour.

Note: If we try to override the final method in subclass then it throw the compile-time error.

Example: Attempt to override (modify) the final method in a subclass.

// Java program demonstrating the use of a final method in a class
// and trying to override the final method
class Greet {
    
    // A final method
    public final void sayHello() {
        System.out.println("Hello from the Greet class!");
    }
}

class ExtendedGreet extends Greet {

    // Trying to override the final method 
     public void sayHello() {
         System.out.println("Hello from the ExtendedGreet class!");
 }
}

public class Geeks {
    public static void main(String[] args) {
        Greet obj = new Greet();
        obj.sayHello();
    }
}

Output:

Explanation: In the above example, we create Greet class and declare a final method sayHello() and then create another class ExtendedGreet, and inherit the properties from Greet class through inheritance and try to modify the final method which will result in compile-time error as shown in the output image.