Programming Tutorials

Polymorphism and Method Overloading in Java

By: Brinda in Java Tutorials on 2007-02-20  

Polymorphism is the ability of an object to take on multiple forms. In Java, it can be achieved through method overriding and method overloading.

Method overriding is the ability of a subclass to provide its own implementation for a method that is already defined in its superclass. The method signature must be the same in both the superclass and the subclass. Here's an example:

class Animal {
   public void makeSound() {
      System.out.println("Animal is making a sound");
   }
}

class Cat extends Animal {
   public void makeSound() {
      System.out.println("Meow");
   }
}

class Dog extends Animal {
   public void makeSound() {
      System.out.println("Woof");
   }
}

public class PolymorphismExample {
   public static void main(String[] args) {
      Animal myCat = new Cat();
      Animal myDog = new Dog();
      myCat.makeSound(); // Output: Meow
      myDog.makeSound(); // Output: Woof
   }
}

In this example, we have an Animal class with a makeSound() method. The Cat and Dog classes extend the Animal class and provide their own implementation of the makeSound() method. In the main() method, we create instances of Cat and Dog, but we store them in variables of type Animal. When we call the makeSound() method on these variables, the appropriate implementation is executed based on the actual object type.

Method overloading is the ability to define two or more methods in the same class with the same name but with different parameters. The method signature must be different for each method. Here's an example:

class Calculator {
   public int add(int x, int y) {
      return x + y;
   }
   public int add(int x, int y, int z) {
      return x + y + z;
   }
}

public class PolymorphismExample {
   public static void main(String[] args) {
      Calculator calculator = new Calculator();
      System.out.println(calculator.add(1, 2)); // Output: 3
      System.out.println(calculator.add(1, 2, 3)); // Output: 6
   }
}

In this example, we have a Calculator class with two add() methods. One takes two parameters, and the other takes three. When we call the add() method on an instance of Calculator, Java determines which method to call based on the number of arguments we provide.

Both method overriding and method overloading are examples of polymorphism in Java.