Differences Between Final and Abstract Methods in Java

in Java, Difference between the final method and the abstract method

In Java, final methods and abstract methods serve different purposes and have distinct characteristics. Here’s a breakdown of the differences between them:

Final Method

1. Definition: A final method is a method that cannot be overridden by subclasses. Once a method is declared as final, its implementation is fixed and cannot be changed in any subclass.

2. Usage: The final keyword is used to prevent method overriding. This is useful when you want to ensure that the behavior of a method remains consistent across all subclasses.

3. Implementation: A final method must have a complete implementation. It cannot be abstract; it must provide a body.

4. Example:

   class Parent {
       final void display() {
           System.out.println("This is a final method.");
       }
   }
   
   class Child extends Parent {
       // This will cause a compile-time error
       // void display() {
       //     System.out.println("Trying to override final method.");
       // }
   }
   

Abstract Method

1. Definition: An abstract method is a method that is declared without an implementation (i.e., it does not have a body). It is meant to be overridden in subclasses.

2. Usage: The abstract keyword is used to define a method that must be implemented by any non-abstract subclass. This is useful for defining a contract that subclasses must adhere to.

3. Implementation: An abstract method cannot have a body and must be declared in an abstract class. Any class that contains an abstract method must also be declared as abstract.

4. Example:

   abstract class Animal {
       abstract void makeSound(); // Abstract method
   }
   
   class Dog extends Animal {
       void makeSound() {
           System.out.println("Bark");
       }
   }
   

Summary of Differences

In summary, use final methods when you want to lock down the implementation, and use abstract methods when you want to enforce a certain behavior that subclasses must implement.