What is Polymorphism in Java?
As developers, we often face situations where we want a single function to behave differently depending on the context. Imagine writing multiple versions of the same method for slightly different tasks. It would make your code long, repetitive, and hard to maintain. This is where polymorphism in Java becomes a real advantage. In simple terms, polymorphism means “many forms.” It allows one method or interface to perform different actions based on the object that uses it. In Java, this feature makes code more flexible and scalable by letting the same code work differently for different classes. Polymorphism is one of the four main pillars of OOP (Object-Oriented Programming), along with inheritance, encapsulation, and abstraction. It supports clean design and reusability — qualities every good Java developer aims for.
There are two main types of polymorphism in Java: compile-time binding (also called method overloading) and runtime binding (also called method overriding). When using runtime polymorphism, the JVM decides which version of the method to call at execution time. In short, polymorphism in Java helps developers write smarter, more adaptable code by allowing the same interface to behave in multiple ways — just like real-world objects do.
Types of Polymorphism in Java
When learning polymorphism in Java, one of the most important things to understand is that it comes in two main types: compile-time and runtime polymorphism. These types decide when the method to be executed is determined — either before the program runs or while it’s running.
1. Compile-Time Polymorphism (Static Polymorphism)
In Java, compile-time polymorphism (also known as static binding) happens when the method to be executed is decided by the compiler before the program runs. This type of polymorphism is mainly achieved using method overloading.
Method overloading means having multiple methods in the same class with the same name but different parameter lists (different number or type of arguments). It allows you to perform similar actions in different ways — without creating separate method names for each case.
Think of it like the print() method in Java. You can use System.out.print() to display text, numbers, or even characters — but Java automatically calls the right version based on what you pass. That’s compile-time polymorphism in action!
Example:
class Printer {
void print(String text) {
System.out.println("Printing text: " + text);
}
void print(int number) {
System.out.println("Printing number: " + number);
}
void print(double value) {
System.out.println("Printing decimal: " + value);
}
}
public class CompileTimePolymorphismExample {
public static void main(String[] args) {
Printer printer = new Printer();
printer.print("Hello, Payilagam!");
printer.print(100);
printer.print(25.75);
}
}In the above program, all three print() methods share the same name but handle different data types. The Java compiler decides which one to run based on the arguments used — this is compile-time binding.
Why it matters: Compile-time polymorphism makes your code cleaner, easier to read, and helps avoid unnecessary method duplication. It’s a key part of writing flexible, object-oriented programs in Java.
2. Runtime Polymorphism (Dynamic Polymorphism)
In Java, runtime polymorphism — also called dynamic binding — happens when the method to be executed is determined while the program is running. This type of polymorphism is achieved through method overriding, where a subclass provides its own version of a method already defined in the superclass.
Unlike compile-time polymorphism, where the method call is fixed during compilation, runtime polymorphism allows Java Virtual Machine (JVM) to decide which method should run based on the object created at runtime. This is also known as dynamic method dispatch.
Let’s look at an example:
class Shape {
void draw() {
System.out.println("Drawing a shape...");
}
}
class Circle extends Shape {
void draw() {
System.out.println("Drawing a circle...");
}
}
class Rectangle extends Shape {
void draw() {
System.out.println("Drawing a rectangle...");
}
}
public class RuntimePolymorphismExample {
public static void main(String[] args) {
Shape s;
s = new Circle(); // reference of parent, object of child
s.draw(); // calls Circle's draw()
s = new Rectangle(); // now refers to Rectangle object
s.draw(); // calls Rectangle's draw()
}
}Output:
Drawing a circle…
Drawing a rectangle…
Explanation: Here, the reference variable s belongs to the Shape class but points to different objects (Circle and Rectangle) at different times. The JVM decides which draw() method to execute during runtime — not during compilation.
This flexibility is what makes runtime polymorphism in Java powerful. It supports real-world OOP principles, allowing programs to become more dynamic, reusable, and easier to extend.
In Short:
1. Compile-time polymorphism → Happens using method overloading (decided before execution).
2. Runtime polymorphism → Happens using method overriding (decided during execution).
Both types make Java more flexible and powerful, allowing programs to adapt behavior based on the class and object in use.
Real Life Example of Polymorphism in Java
In the real world, polymorphism is everywhere — it simply means one action behaving in different ways depending on the situation. In Java, polymorphism is an important concept in Object-Oriented Programming (OOP) that allows the same method name to perform different actions based on the object that calls it. Let’s look at a simple real life example of polymorphism in Java using a Vehicle system.
class Vehicle {
void start() {
System.out.println("Starting the vehicle...");
}
}
class Car extends Vehicle {
void start() {
System.out.println("Car is starting with a key.");
}
}
class Bike extends Vehicle {
void start() {
System.out.println("Bike is starting with a self-start button.");
}
}
public class PolymorphismExample {
public static void main(String[] args) {
Vehicle v1 = new Car();
Vehicle v2 = new Bike();
v1.start(); // Calls Car's start() method
v2.start(); // Calls Bike's start() method
}
}Explanation: In this polymorphism in Java real-time example, the same method start() behaves differently based on the object type — Car or Bike. This is achieved using method overriding, which is a form of runtime polymorphism.
Similarly, in business software:
->In a company system, the base class Employee might have a work() method.
->The subclasses like Manager, Developer, or Tester can override work() to define their own tasks.
This allows the same method name to perform unique actions for each employee type — making programs easier to manage and extend as the system grows.
Practical View:
Imagine an application that manages files or user operations. Java file handling classes like FileReader, BufferedReader, and InputStreamReader also show polymorphism. They all use the same read() method name but handle data differently based on the class type.
Why It Matters: Polymorphism in Java is important because it makes applications more flexible and scalable. Developers can write one general method or interface, and different classes can implement or override it as per their behavior — saving time and improving maintainability.
Polymorphism in Java with Example Programs
For a beginner, understanding polymorphism in Java with example programs becomes easier when you see how the same method can perform different actions. Simply put, polymorphism means many forms — and in Java, it happens when a method in the subclass overrides a method in the parent class or when method overloading allows multiple methods with the same name but different parameters. Let’s look at simple polymorphism examples one by one:
1. Method Overloading Example (Compile-Time Polymorphism)
Here, method overloading allows the same method name but with different argument types or counts.
class Calculator {
int add(int a, int b) {
return a + b;
}
double add(double a, double b, double c) {
return a + b + c;
}
}
public class OverloadingExample {
public static void main(String[] args) {
Calculator calc = new Calculator();
System.out.println("Sum of two numbers: " + calc.add(5, 10));
System.out.println("Sum of three numbers: " + calc.add(2.5, 3.5, 4.5));
}
}Explanation: The add() method performs addition for both integers and doubles — showing compile-time polymorphism because the compiler decides which method to call based on parameters.
2. Method Overriding Example (Runtime Polymorphism)
Here, a method in the subclass overrides a method in its superclass to change its behavior.
class Shape {
void draw() {
System.out.println("Drawing a shape...");
}
}
class Circle extends Shape {
void draw() {
System.out.println("Drawing a circle...");
}
}
class Rectangle extends Shape {
void draw() {
System.out.println("Drawing a rectangle...");
}
}
public class OverridingExample {
public static void main(String[] args) {
Shape s1 = new Circle();
Shape s2 = new Rectangle();
s1.draw();
s2.draw();
}
}Explanation: Here, both subclasses override the draw() method to provide their own implementation. This is runtime polymorphism because the JVM (Java Virtual Machine) decides which version to run during execution.
3. Real-World Polymorphism Example (Bank System)
class Bank {
double getRateOfInterest() {
return 5.0;
}
}
class SBI extends Bank {
double getRateOfInterest() {
return 6.5;
}
}
class HDFC extends Bank {
double getRateOfInterest() {
return 7.0;
}
}
public class BankExample {
public static void main(String[] args) {
Bank b1 = new SBI();
Bank b2 = new HDFC();
System.out.println("SBI Rate of Interest: " + b1.getRateOfInterest());
System.out.println("HDFC Rate of Interest: " + b2.getRateOfInterest());
}
}Explanation: Each bank has its own rate of interest, but all share the same method name getRateOfInterest(). This shows method overriding and real-world runtime polymorphism in Java.
4. Polymorphism in Java Algorithms
Even Java algorithms use polymorphism. For example, sorting methods in Java’s Collections Framework use method overloading and interfaces (like Comparator and Comparable) to perform operations differently for various data types — all through polymorphism!
In Short:
- -> Compile-Time Polymorphism → Achieved through Method Overloading
- -> Runtime Polymorphism → Achieved through Method Overriding
- -> Both help make Java programs more flexible, efficient, and easier to maintain.
Common Interview Questions on Polymorphism in Java
When it comes to Java interviews, polymorphism is one of the most important topics from the Object-Oriented Programming (OOP) concepts. Interviewers often check whether you understand the difference between compile-time polymorphism and run-time polymorphism, and how Java allows the same method name to behave differently based on context. Below are some frequently asked Java polymorphism interview questions with short, easy-to-understand answers:
1. What is polymorphism in Java?
Polymorphism in Java allows an object to take many forms. It lets the same method name perform different tasks depending on the object that calls it. It helps make programs more flexible and maintainable.
2. What are the two types of polymorphism in Java?
- -> Compile-Time Polymorphism (also known as Static Polymorphism) – achieved through Method Overloading.
- -> Runtime Polymorphism (also known as Dynamic Polymorphism) – achieved through Method Overriding.
3. What is the difference between method overloading and method overriding?
- -> Method Overloading occurs within the same class and is based on different parameter lists (compile-time polymorphism).
- -> Method Overriding happens between parent and child classes where the subclass overrides a method from the superclass (runtime polymorphism).
4. Can we achieve runtime polymorphism using static methods?
No, static methods belong to the class, not to objects. Hence, runtime polymorphism cannot be achieved with static methods — they are resolved during compile time, not at runtime.
5. What is a runtime polymorphism example in Java?
When a parent class reference variable refers to a child class object and calls an overridden method.
Example: Parent obj = new Child();
obj.show(); // Calls Child's version of show()Here, the overridden method from the subclass executes — showing run-time polymorphism.
6. What is compile-time polymorphism in Java?
It is the type of polymorphism resolved during compilation. Method overloading is a good example, where multiple methods with the same name but different parameters exist in the same class.
7. Can we override private or final methods in Java?
No. Private methods are not visible to subclasses, and final methods cannot be modified — so they can’t be overridden.
8. Why is polymorphism important in Java programming language?
Polymorphism helps in achieving code reusability, flexibility, and extensibility. It allows Java developers to write cleaner code that can handle future changes easily.
9. How does Java achieve runtime polymorphism?
Through method overriding and dynamic method dispatch, where the JVM decides at runtime which version of the method to execute based on the actual object type.
10. Can constructors be overridden in Java?
No. Constructors cannot be inherited or overridden. They are only used for object creation, not for polymorphism.
Difference Between Static and Dynamic Polymorphism
In Java, polymorphism is one of the most important concepts of Object-Oriented Programming (OOP). It allows the same method name to perform different actions depending on the context. There are two main types: Static (Compile-Time) Polymorphism and Dynamic (Runtime) Polymorphism.
Both work differently — one is decided during compilation, while the other is determined when the program runs. Understanding this difference between compile-time and runtime polymorphism is essential for writing efficient and flexible Java code.
Comparison Table: Static vs Dynamic Polymorphism
| Basis of Comparison | Static (Compile-Time) Polymorphism | Dynamic (Runtime) Polymorphism |
| Definition | Occurs when a method call is resolved during compile time. | Occurs when a method call is resolved at runtime. |
| Achieved By | Using Method Overloading (same method name with different parameters). | Using Method Overriding (method in the subclass overrides the method in the superclass). |
| Binding Type | Uses compile-time binding. | Uses runtime binding. |
| Decision Time | Decided by the compiler before the program runs. | Decided by the JVM while the program is running. |
| Inheritance Requirement | Does not require inheritance. | Requires inheritance between parent and child classes. |
| Flexibility | Less flexible but faster. | More flexible but slightly slower due to runtime decision-making. |
| Example | Multiple add() methods with different parameters. | Parent class display() overridden by child class display(). |
| Use Case | Used for tasks known at compile time. | Used for tasks known at compile time. |
Simple Summary for Freshers:
Simple Summary for Freshers:
Think of static polymorphism like planning everything before a trip — routes, hotels, and timings are fixed. But dynamic polymorphism is like deciding things during the journey — you adapt based on the situation. Both are vital in the concept of compile-time and runtime polymorphism, helping developers create efficient and adaptive Java applications.
Advantages and Disadvantages of Using Polymorphism
In Java, polymorphism makes programs more flexible, organized, and easier to maintain. It’s one of the key features of Object-Oriented Programming (OOP) that allows a single method or action to behave differently based on the object it belongs to. Let’s look at the benefits of polymorphism in Java and a few limitations that developers should be aware of.
Advantages of Polymorphism in Java
- Code Reusability: Polymorphism allows you to use the same method name for different tasks. This avoids code duplication and makes programs cleaner and easier to update.
- Flexibility and Extensibility: You can easily add new classes or methods without changing existing code. This makes Java programs more flexible and scalable as they grow.
- Simplified Code Maintenance: Since polymorphism keeps related methods together, developers can manage and debug code with less effort. It improves code readability and reduces errors.
- Supports OOP Principles: It strengthens inheritance and encapsulation, allowing objects to interact in a consistent way while still behaving differently.
- Better Performance in Real Projects: In large applications (like banking or e-commerce), polymorphism allows developers to build modular systems where each class performs a specific role efficiently.
Disadvantages of Polymorphism in Java
- Complexity for Beginners: Understanding how overriding and overloading work together can be confusing for new learners.
- Slight Performance Overhead: Since runtime polymorphism involves decision-making by the JVM, it can be slightly slower than compile-time execution.
- Debugging Difficulty: When multiple classes override the same method, tracing which method is actually called at runtime can be tricky.
Simple Summary: Polymorphism is like having a universal tool that changes its function based on what you need. It makes coding reusable, flexible, and powerful. While it may take a little practice to master, the benefits of polymorphism in Java far outweigh its limitations, especially when building real-world, object-oriented applications.
Summary and Key Takeaways
Polymorphism in Java is one of the most important concepts in Object-Oriented Programming (OOP). It allows one method to perform different tasks based on the object that calls it, making code more flexible and efficient.
Throughout this blog, we explored the types of polymorphism — compile-time polymorphism using method overloading and runtime polymorphism using method overriding. We also discussed how compile-time binding and runtime binding help the JVM decide which version of a method to run during program execution.
Using inheritance, classes, and interfaces, we can create relationships between objects that bring real-world behavior into our Java applications. From simple to real-life examples like vehicles and employees, polymorphism proves to be a foundation for building scalable and maintainable software.
Key Takeaways
- -> Polymorphism improves code reusability, flexibility, and maintainability.
- -> Method Overloading represents compile-time polymorphism, while Method Overriding represents runtime polymorphism.
- -> It helps developers design programs that are easier to understand and extend.
- -> Mastering polymorphism is essential for writing professional and efficient Java code.
At Payilagam, we make complex Java concepts simple and practical. As the Best Software Training Institute in Chennai, our Full-Stack Java Training in Chennai helps learners master everything from OOP principles to real-time project implementation. Join Payilagam’s Java Full Stack Java Course in Chennai, and attend a free demo class to start your journey toward becoming a confident Java developer.
