Java Polymorphism: Types And Examples (Geekster)

JAVA ROADMAP
Java Polymorphism – Types And
Examples
Polymorphism is one of the 4 pillars of Object-Oriented Programming. It is a
combination of two Greek words: poly and morphs. “Poly” means “many,” and
“morphs” means “forms.” So in Java, polymorphism means many forms.
Polymorphism is defined as the ability of a message to be displayed in more than
one form.
Let’s understand the meaning of polymorphism by an example:
Consider a woman in society. The same woman performs different roles in society.
The woman can be the wife of someone, the mother of her child, can be at the role
of a manager in an organization, and many more at the same time. But the Woman
is only one. So, the same woman performing different roles is polymorphism.
Another best example is your smartphone. The smartphone can act as a phone,
camera, music player, alarm, and whatnot, taking different forms and hence
polymorphism

Introduction
Polymorphism in Java refers to an object’s ability to take on multiple forms or types.
It enables the treatment of objects of different classes as objects of a common
superclass or interface. In simpler terms, polymorphism allows us to represent
different types of objects using a single variable or method.
We can relate polymorphism in real life by the following example. Consider different
types of animals. Each animal makes a distinct sound. By leveraging polymorphism,
you can define a common “makeSound” method in a superclass called “Animal,”
which is overridden in each subclass with the specific sound implementation.
// Base class Animal
class Animal {
public void makeSound() {
System.out.println("Animal making a generic sound...");
}
}
// Subclass Dog
class Dog extends Animal {
// Override the makeSound method in the Dog class
System.out.println("Dog barking: Woof!");

}
}
// Subclass Cat
class Cat extends Animal {
// Override the makeSound method in the Cat class
System.out.println("Cat meowing: Meow!");
}
}
// Subclass Cow
class Cow extends Animal {
// Override the makeSound method in the Cow class
System.out.println("Cow mooing: Moo!");
}
}
public class Main {
public static void main(String[] args) {
Animal dog = new Dog();
Animal cat = new Cat();
Animal cow = new Cow();
dog.makeSound();
cat.makeSound();
cow.makeSound();
}
}
Output:
Dog barking: Woof!
Cat meowing: Meow!
Cow mooing: Moo!
In this example, we have a base class Animal with a makeSound method. The
subclasses Dog, Cat, and Cow inherit from the Animal class and override the
makeSound method with their specific sound. By creating objects of each subclass
and calling the makeSound method, we observe polymorphic behavior where each
animal produces its unique sound.
This example demonstrates how polymorphism allows for the flexibility of handling
different objects through a common interface or superclass, enabling code reuse and
promoting flexibility in real-life scenarios.

How polymorphism can be achieved?
Polymorphism in Java can be achieved through two concepts i.e. method
overloading and method overriding. Let’s dive into each of these concepts:
Method Overloading
Polymorphism via method overloading enables a class to have multiple methods with
the same name but different parameters. The methods can perform similar actions
but with different data types or parameters. The Java compiler determines which
method to invoke based on the method call arguments.
Example:
class Calculator {
public int add(int a, int b) {
return a + b;
}
public double add(double a, double b) {
return a + b;
}
}
public class Main {
Calculator calculator = new Calculator();
System.out.println(calculator.add(5, 10)); // Output: 15
System.out.println(calculator.add(3.5, 2.5)); // Output: 6.0
}
}
In the example above, the Calculator class has two add() methods. One accepts two
integers as parameters, while the other accepts two doubles. Depending on the
arguments passed during the method call, the compiler determines the appropriate
method to invoke. This allows us to use the same method name add() for different
data types, enhancing code readability and flexibility.
Method Overriding
Polymorphism through method overriding allows a subclass to provide its own
implementation of a method defined in its parent class. It involves creating a method
in the subclass with the same name, return type, and parameters as the method in
the parent class. The method in the subclass overrides the implementation of the
method in the parent class, allowing the subclass to exhibit its unique behavior.

Example:
class Animal {
System.out.println("Animal makes a sound");
}
}
@Override
System.out.println("Dog barks");
}
}
public class Main {
Animal animal = new Dog();
animal.makeSound(); // Output: Dog barks
}
}
In the example above, we have a superclass called Animal with a makeSound()
method. The Dog class extends the Animal class and overrides the makeSound()
method with its own implementation. When we create an object of type Animal and
assign it to a Dog object, and then call the makeSound() method, it invokes the
overridden method in the Dog class, displaying “Dog barks” as the output.
Types Of Polymorphism In Java
There are two types of polymorphism in Java: compile-time polymorphism (also
known as method overloading) and runtime polymorphism (also known as method
overriding).
1. Compile-Time Polymorphism (Method Overloading)
This type of polymorphism in Java is also called static polymorphism or static
method dispatch. It can be achieved by method overloading. In this process, an
overloaded method is resolved at compile time rather than resolving at runtime.
● Method overloading allows a class to have multiple methods with the same
name but different parameters.

● Based on the number and type of the arguments passed the compiler
determines which method to call.
● The methods may have different return types, but this alone is insufficient
to distinguish overloaded methods.
Example 1: Method Overloading with Different Number of Parameters
public class Calculator {
public int add(int a, int b) {
return a + b;
}
public int add(int a, int b, int c) {
return a + b + c;
}
Calculator calculator = new Calculator();
System.out.println(calculator.add(2, 3));
System.out.println(calculator.add(2, 3, 4));
}
}
Output:
5
9
In this example, the Calculator class has two add methods. The first add method
takes two parameters, a and b, and returns their sum. The second add method takes
three parameters, a, b, and c, and returns their sum. The two methods have the
same name but different numbers of parameters. Depending on the number of
arguments passed the compiler selects the appropriate method.
Example 2: Method Overloading with Different Types of Parameters
public class Converter {
public String convertToString(int number) {
return String.valueOf(number);
}
public String convertToString(double number) {
return String.valueOf(number);
}

Converter converter = new Converter();
System.out.println(converter.convertToString(42));
System.out.println(converter.convertToString(3.14));
}
}
Output:
42
3.14
In this example, the Converter class has two convertToString methods. The first
convertToString method takes an int parameter and converts it to a String. The
second convertToString method takes a double parameter and converts it to a String.
The two methods have the same name but different types of parameters. Based on
the type of the argument passed the compiler determines which method to invoke.
2. Runtime Polymorphism (Method Overriding)
Dynamic method dispatch is another name for runtime polymorphism. This
polymorphism is achieved by method overriding. The overridden method is resolved
at runtime rather than at compile time.
In Java, runtime polymorphism occurs when two or more classes are related through
inheritance. We must create an “IS-A” relationship between classes and override a
method to achieve runtime polymorphism.
● Method overriding occurs when a subclass implements a method that is
already defined in the parent class.
● The must rule of method overriding is that the subclass method must have
the same name, return type, and parameter list as the parent class
method.
● The method to invoke is determined at runtime based on the actual type of
the object.
● The @Override annotation (optional but recommended) is frequently used
to indicate that a method is intended to override a superclass method.
Example 1: Method Overriding
class Animal {

System.out.println("Animal is making a sound");
}
}
class Cat extends Animal {
@Override
System.out.println("Cat is meowing");
}
}
@Override
System.out.println("Dog is barking");
}
}
public class Main {
Animal animal1 = new Cat();
Animal animal2 = new Dog();
animal1.makeSound();
animal2.makeSound();
}
}
Output:
Cat is meowing
Dog is barking
VISIT
BLOG.GEEKSTER.IN
FOR THE REMAINING

Java Polymorphism: Types And Examples (Geekster)

More Related Content

What's hot

Similar to Java Polymorphism: Types And Examples (Geekster)

More from Geekster

Recently uploaded

Java Polymorphism: Types And Examples (Geekster)