Javatpoint Logo
Javatpoint Logo

Final Method Overloading in Java| Can We Overload Final Methods?

Java, being an object-oriented programming language, provides a powerful mechanism known as method overloading, allowing developers to define multiple methods with the same name but different parameters within the same class. However, when it comes to final methods, a question arises: can we overload final methods in Java?

Method Overloading in Java

Method overloading is a feature in Java that allows a class to have multiple methods with the same name, but with different parameter lists. It provides flexibility and enhances code readability. Overloaded methods are differentiated by the number, types, and order of their parameters.

In the example above, the MathOperations class has two overloaded add() methods, one for integer parameters and another for double parameters.

The Final Keyword in Java

The final keyword in Java is used to denote that a variable, method, or class cannot be further modified or extended. When applied to a method, it prevents the method from being overridden by subclasses. However, the question is whether we can overload a final method in Java.

Final Method Overloading

In Java, it is possible to overload a final method. Method overloading is determined by the method signature that includes the method name and the parameter list. Since method overloading is based on the parameter list and not the return type or other modifiers, it is still valid to provide a different set of parameters for a final method in the same class.

In the example above, the FinalMethodExample class has a final method named display(), and it is overloaded with a second version that takes an additional int parameter. It demonstrates that final methods can be overloaded as long as the method signatures differ.

Why Overload Final Methods?

While overloading final methods might seem counterintuitive, it can be useful in certain scenarios. When designing a class hierarchy, we may have a final method in the base class that serves a common purpose. Overloading this method in derived classes can allow for customization while still preserving the finality of the base class method.

In this example, the Shape class has a final method draw(), and the derived classes (Circle and Rectangle) provide overloaded versions of the draw() method that include additional parameters specific to each shape.


Drawing a generic shape            // Output from the final method in Shape class
Drawing a circle with radius: 5    // Output from the overloaded method in Circle class
Drawing a generic shape            // Output from the final method in Shape class
Drawing a rectangle with length 4 and width 6 // Output from the overloaded method in Rectangle class

In this example, the draw method in the Shape class is final, preventing further modification. The derived classes, Circle and Rectangle, provide additional functionality by overloading the draw() method with parameters specific to each shape. The output demonstrates how the correct overloaded method is called based on the provided arguments.

To compile and run the Java code provided, we will follow the steps given below:

Save the Code

Copy the Java code provided for Shape, Circle, Rectangle, and FinalMethodOverloadingExample into separate files with the corresponding class names and a .java extension. For example, create four files:,,, and

Open a Terminal or Command Prompt

Open a terminal or command prompt on your computer.

Navigate to the Directory

Use the cd command to navigate to the directory where we saved our Java files. For example, if we saved them on the desktop, we might use:

Compile the Code

Use the javac command to compile the Java source files. For example:

The command compiles all four files and generates corresponding .class files.

Run the Program

Once compiled, we can run the Java program using the java command:

The command executes the FinalMethodOverloadingExample class, and we should see the output in the terminal.


In Java, final methods can be overloaded, and doing so does not violate the principles of method overloading or the final keyword. Overloading final methods can provide flexibility in class design, allowing for customization in derived classes while preserving the immutability of certain base class methods. However, it's crucial to carefully consider the design implications and ensure that overloading final methods aligns with the intended behavior and hierarchy of the class structure.

Youtube For Videos Join Our Youtube Channel: Join Now


Help Others, Please Share

facebook twitter pinterest

Learn Latest Tutorials


Trending Technologies

B.Tech / MCA