Course: Core Java Training
Topic: Implementing Method Overloading and Method Overriding
Course Link: Core Java Training Course
Demo Link: Register for a Course Demo
Website: JustAcademy
Methods are an essential part of Java programming. They define the operations an object or class can perform and help developers organize reusable code. Java supports two important techniques for working with methods: method overloading and method overriding.
Both techniques allow methods with related purposes to share the same name, but they work differently. Method overloading allows multiple methods in the same class, or an inherited class context, to use the same name with different parameter lists. Method overriding allows a subclass to provide its own implementation of an eligible instance method inherited from a superclass.
These concepts support readable code, reusable functionality, and polymorphism. Understanding the differences between them is important for writing effective object-oriented Java programs.
Method overloading is a Java feature that allows multiple methods to have the same name but different parameter lists. The methods can differ in the number of parameters, their data types, or their parameter order.
Overloaded methods commonly perform related operations while accepting different forms of input. For example, a calculator class might provide multiple add() methods to add two integers, three integers, or two decimal numbers.
The compiler determines which overloaded method to call by examining the method arguments and the available method signatures during compilation.
Java identifies methods using their names and parameter types. To overload a method, change its parameter list in a way that creates a distinct method signature.
class Display {
void show(int number) {
System.out.println("Number: " + number);
}
void show(int number, String text) {
System.out.println("Number: " + number);
System.out.println("Text: " + text);
}
}The first method accepts one argument, while the second accepts two.
class Printer {
void print(int value) {
System.out.println("Integer: " + value);
}
void print(String value) {
System.out.println("String: " + value);
}
}Both methods are named print(), but one accepts an integer and the other accepts a string.
class Information {
void display(String name, int age) {
System.out.println(name + " is " + age + " years old.");
}
void display(int age, String name) {
System.out.println(name + " is " + age + " years old.");
}
}The parameter types appear in a different order, so the methods have different signatures.
// Invalid Java example
class Example {
int calculate(int value) {
return value * 2;
}
// Compilation error: same method signature
// double calculate(int value) {
// return value * 2.0;
// }
}The two declarations have the same name and parameter list. A different return type alone does not make them valid overloads.
```htmlThe following program demonstrates method overloading by defining multiple versions of an add() method. Each version accepts a different number or type of arguments.
class Calculator {
int add(int a, int b) {
return a + b;
}
int add(int a, int b, int c) {
return a + b + c;
}
double add(double a, double b) {
return a + b;
}
public static void main(String[] args) {
Calculator calculator = new Calculator();
System.out.println(calculator.add(10, 20));
System.out.println(calculator.add(10, 20, 30));
System.out.println(calculator.add(5.5, 4.5));
}
}Output:
30
60
10.0add(int a, int b) adds two integers.add(int a, int b, int c) adds three integers.add(double a, double b) adds two decimal values.add(), but their parameter lists differ.addTwoNumbers() and addThreeNumbers() for closely related operations.Method overriding occurs when a subclass provides a new implementation of an eligible instance method inherited from a superclass. The overriding method uses a compatible signature and return type, allowing the subclass to customize the inherited behavior.
Method overriding requires an inheritance relationship, such as a class extending another class or implementing an interface method. It is a major feature of runtime polymorphism because Java can select the implementation associated with the actual object's class when an overridden instance method is invoked.
@Override annotation helps the compiler verify the programmer's intention.A subclass can override an eligible inherited instance method. For example, a Dog class can override an accessible makeSound() method declared in an Animal superclass.
The method name and parameter types must match the inherited method's signature. If the parameter list changes, the subclass may be declaring an overloaded method instead of overriding the inherited one.
An overriding method can use the same return type or a permitted covariant reference return type. An incompatible return type results in a compilation error.
An overriding method can have the same or wider accessibility, but it cannot reduce the access level of the inherited method. For example, a public method cannot be overridden with a protected or private method.
The @Override annotation tells the compiler that a method is intended to override an inherited method. If the declaration does not actually override a suitable method, the compiler reports an error.
This example demonstrates how a subclass can customize a method inherited from its superclass.
class Animal {
void makeSound() {
System.out.println("Animal makes a sound.");
}
}
class Dog extends Animal {
@Override
void makeSound() {
System.out.println("Dog barks.");
}
}
class Cat extends Animal {
@Override
void makeSound() {
System.out.println("Cat meows.");
}
}
public class OverridingDemo {
public static void main(String[] args) {
Animal animal = new Animal();
Animal dog = new Dog();
Animal cat = new Cat();
animal.makeSound();
dog.makeSound();
cat.makeSound();
}
}Output:
Animal makes a sound.
Dog barks.
Cat meows.Animal defines the original makeSound() method.Dog overrides the method to print a dog-specific sound.Cat overrides the same method to print a cat-specific sound.dog and cat are declared using the parent type, Animal, but refer to different subclass objects.Runtime polymorphism occurs when an overridden instance method is selected according to the actual object at runtime. It allows code to work with a superclass or interface type while supporting different implementations.
class Payment {
void processPayment() {
System.out.println("Processing a general payment.");
}
}
class CardPayment extends Payment {
@Override
void processPayment() {
System.out.println("Processing card payment.");
}
}
class UpiPayment extends Payment {
@Override
void processPayment() {
System.out.println("Processing UPI payment.");
}
}
public class PaymentDemo {
public static void main(String[] args) {
Payment payment;
payment = new CardPayment();
payment.processPayment();
payment = new UpiPayment();
payment.processPayment();
}
}Output:
Processing card payment.
Processing UPI payment.The variable payment has the type Payment, but it refers to different subclass objects. The actual object's class determines which overridden instance method is executed.
This approach is useful in payment systems, notification services, reporting tools, and other applications where multiple implementations follow a common interface.
The super keyword allows a subclass to invoke the superclass implementation of an overridden method. This is useful when the subclass wants to retain some of the original behavior while adding its own functionality.
class Employee {
void displayRole() {
System.out.println("General employee.");
}
}
class Manager extends Employee {
@Override
void displayRole() {
super.displayRole();
System.out.println("Manages a team.");
}
}
public class SuperMethodDemo {
public static void main(String[] args) {
Manager manager = new Manager();
manager.displayRole();
}
}Output:
General employee.
Manages a team.The Manager class first invokes the superclass implementation through super.displayRole() and then executes its own additional statement.
Although the two concepts use methods with the same name, they differ in their requirements and behavior.
| Basis | Method Overloading | Method Overriding |
|---|---|---|
| Meaning | Same method name with different parameter lists. | A subclass provides a new implementation of an eligible inherited instance method. |
| Inheritance required | No. | Yes, through class inheritance or interface implementation. |
| Parameters | Must differ in number, types, or order. | Must match the inherited method's parameter types. |
| Return type | May differ if the parameter lists distinguish the methods; return type alone cannot distinguish an overload. | Must be the same or a permitted covariant reference type. |
| Polymorphism | Commonly called compile-time polymorphism. | Supports runtime polymorphism for instance methods. |
| Method selection | The compiler resolves the applicable overload using argument types and method resolution rules. | The implementation of the actual object's class is selected at runtime for an overridden instance method. |
| Annotation | No special annotation is required. | @Override is recommended. |
| Example | add(int, int) and add(double, double). |
Dog.makeSound() overrides Animal.makeSound(). |
Polymorphism means that a common method name or type can support different operations or implementations. Method overloading and method overriding contribute to polymorphism in different ways.
Method overloading is associated with compile-time polymorphism because the compiler determines which overload is applicable based on the method call's argument types and other method-resolution rules.
class Message {
void display(String text) {
System.out.println(text);
}
void display(int number) {
System.out.println(number);
}
}Method overriding is associated with runtime polymorphism because an overridden instance method is dispatched according to the actual object being used.
class Shape {
void draw() {
System.out.println("Drawing a shape.");
}
}
class Circle extends Shape {
@Override
void draw() {
System.out.println("Drawing a circle.");
}
}When draw() is called through a Shape reference that refers to a Circle object, Java executes the overridden implementation in Circle.
Static methods belong to a class rather than to a particular instance. They can be overloaded when the parameter lists differ, but static methods are not overridden in the same way as instance methods.
class Utility {
static void print(int number) {
System.out.println("Integer: " + number);
}
static void print(String text) {
System.out.println("Text: " + text);
}
}
public class StaticOverloadingDemo {
public static void main(String[] args) {
Utility.print(10);
Utility.print("Java");
}
}Output:
Integer: 10
Text: Javaclass Parent {
static void show() {
System.out.println("Parent static method.");
}
}
class Child extends Parent {
static void show() {
System.out.println("Child static method.");
}
}
public class StaticMethodDemo {
public static void main(String[] args) {
Parent.show();
Child.show();
}
}Output:
Parent static method.
Child static method.This is called method hiding, not method overriding. The method invoked depends on the class through which the static method is called.
A notification service can use method overloading to support different input formats and method overriding to customize delivery behavior for different notification types.
class Notification {
void send(String message) {
System.out.println("Notification: " + message);
}
void send(String message, String recipient) {
System.out.println("To: " + recipient);
System.out.println("Notification: " + message);
}
}
class EmailNotification extends Notification {
@Override
void send(String message) {
System.out.println("Sending email: " + message);
}
}
class SmsNotification extends Notification {
@Override
void send(String message) {
System.out.println("Sending SMS: " + message);
}
}
public class NotificationDemo {
public static void main(String[] args) {
Notification notification = new Notification();
notification.send("Welcome!");
notification.send("Your account is ready.", "[email protected]");
Notification email = new EmailNotification();
Notification sms = new SmsNotification();
email.send("Your report is ready.");
sms.send("Your verification code is 1234.");
}
}Output:
Notification: Welcome!
To: [email protected]
Notification: Your account is ready.
Sending email: Your report is ready.
Sending SMS: Your verification code is 1234.Notification class overloads send() to accept different parameter lists.EmailNotification and SmsNotification override the one-argument send() method.| Error or Mistake | Cause | Solution |
|---|---|---|
| Overloading methods by return type only | The parameter lists are identical, so the declarations conflict. | Change the parameter list or use a distinct method name. |
| Incorrect method signature while overriding | The subclass method has different parameter types or a different name. | Match the inherited method signature and use @Override. |
| Reducing method visibility | The overriding method is less accessible than the inherited method. | Keep the same or wider access level. |
| Overriding a final method | Methods declared final cannot be overridden. |
Use the inherited method or redesign the superclass if appropriate. |
| Trying to override a static method | Static methods are hidden, not overridden. | Use instance methods when runtime polymorphism is required. |
| Unexpected overloaded method selection | The compiler uses the argument types and method-resolution rules, not just the runtime class of an argument. | Review the declared types, available overloads, and possible conversions. |
| Ambiguous overloaded call | More than one overload may be applicable without a single most-specific choice. | Use clearer parameter types or explicitly cast arguments where appropriate. |
@Override to overridden methods to catch signature mistakes.super.methodName() when the parent implementation should be preserved as part of the subclass behavior.multiply() methods for two integers, three integers, and two double values.calculateArea() methods for a square and rectangle using different parameter lists.Employee class with a displayDetails() method. Override it in Manager and Developer.Animal class and override makeSound() in Dog, Cat, and Cow.int, double, and String arguments. Predict the selected method for several calls and then verify the results.Objective: Build a small Java program that uses method overloading and method overriding to calculate or display shape information.
Shape with a display() method.Circle and Rectangle.display() in each subclass to print shape-specific details.calculateArea() methods that accept appropriate parameters for a circle and a rectangle.After completing this project, learners should be able to distinguish method overloading from overriding, select suitable method signatures, apply inheritance, and understand how Java chooses overloaded and overridden methods.
Answer: Method overloading allows multiple methods to share the same name while having different parameter lists. It is commonly associated with compile-time polymorphism.
Answer: Method overriding occurs when a subclass provides a compatible implementation of an eligible inherited instance method. It supports runtime polymorphism.
Answer: No. The parameter lists must distinguish overloaded methods. Changing only the return type is not sufficient.
Answer: No. Methods can be overloaded within a single class. Inheritance may also be involved in an overloaded method set.
Answer: Yes. Overriding involves providing an implementation for an eligible inherited instance method, including methods inherited through an interface.
Answer: It indicates that a method is intended to override an inherited method and allows the compiler to detect mistakes in the declaration.
Answer: No. A static method with the same signature in a subclass hides the superclass method instead of overriding it.
Answer: No. A private method is not inherited as an accessible method by a subclass. A same-named method declared in the subclass is a separate method.
Answer: Runtime polymorphism occurs when Java selects an overridden instance method according to the actual object's class at runtime.
Answer: Overloading uses the same method name with different parameter lists and is resolved at compile time. Overriding provides a subclass-specific implementation of an inherited instance method and uses runtime method dispatch.
Answer: It can use the same return type or a permitted covariant reference return type. An incompatible return type is not allowed.
Answer: No. An overriding method must have the same or wider accessibility than the overridden method.
Answer: No. Constructors are not inherited, so they cannot be overridden. Constructors can be overloaded using different parameter lists.
Answer: Yes. A subclass can declare another method with the same name but a different parameter list, provided the declarations are valid.
Answer: It allows a subclass to call the superclass implementation of an overridden method.
@Override annotation is recommended for overriding methods.super keyword can call the superclass implementation of an overridden method.Method overloading and method overriding are essential concepts in Java's object-oriented programming model. Overloading makes methods more flexible by allowing related operations to use the same name with different parameter lists. Overriding allows subclasses to customize inherited behavior and is fundamental to runtime polymorphism.
To master these concepts, practice writing overloaded calculator methods, overriding methods in class hierarchies, and using superclass references to work with different subclass objects. Understanding method signatures, access rules, return types, and the role of @Override will help you write clearer and more reliable Java programs.
Explore the Core Java Training Course to continue learning Java methods, classes, objects, inheritance, polymorphism, and other object-oriented programming concepts.
Register for a Course Demo to learn more about the training, or visit the JustAcademy website.
