Java Notes

Polymorphism in Java

Complete guide to polymorphism in Java — compile-time vs runtime polymorphism, method dispatch, upcasting, downcasting, and designing extensible systems with polymorphic code.

Polymorphism means "many forms." In Java, it's the ability of a single interface to represent different underlying types. The same method call can behave differently depending on the actual object type.

Polymorphism is arguably the most powerful OOP concept. It lets you write flexible, extensible code that works with objects you haven't even created yet.

Two Types of Polymorphism

Type	Mechanism	Binding	Also Called
Compile-time	Method Overloading	Static (compile time)	Static Polymorphism
Runtime	Method Overriding	Dynamic (runtime)	Dynamic Polymorphism

Compile-Time Polymorphism (Overloading)

The compiler decides which method to call based on the argument types:

java example

public class Calculator {
    public int calculate(int a, int b) {
        return a + b;
    }

    public double calculate(double a, double b) {
        return a + b;
    }

    public int calculate(int a, int b, int c) {
        return a + b + c;
    }

    public String calculate(String a, String b) {
        return a + b;  // String concatenation
    }
}

public class Main {
    public static void main(String[] args) {
        Calculator calc = new Calculator();
        System.out.println(calc.calculate(5, 3));           // int version
        System.out.println(calc.calculate(2.5, 3.7));       // double version
        System.out.println(calc.calculate(1, 2, 3));        // three-param version
        System.out.println(calc.calculate("Hello", " World")); // String version
    }
}

Output

8
6.2
6
Hello World

Runtime Polymorphism (Overriding)

The JVM decides which method to call based on the actual object type at runtime. This is the real power:

Example

public class Notification { protected String message; protected String recipient; public Notification(String message, String recipient) { this.message = message; this.recipient = recipient; } public void send() { System.out.println("Sending notification to " + recipient); } public double getCost() { return 0.0; } } public class EmailNotification extends Notification { private String subject; public EmailNotification(String message, String recipient, String subject) { super(message, recipient); this.subject = subject; } @Override public void send() { System.out.println("📧 Email to " + recipient + " | Subject: " + subject + " | Body: " + message); } @Override public double getCost() { return 0.001; } } public class SMSNotification extends Notification { public SMSNotification(String message, String recipient) { super(message, recipient); } @Override public void send() { System.out.println("📱 SMS to " + recipient + ": " + message); } @Override public double getCost() { return 0.05; } } public class PushNotification extends Notification { private String appName; public PushNotification(String message, String recipient, String appName) { super(message, recipient); this.appName = appName; } @Override public void send() { System.out.println("🔔 Push [" + appName + "] to " + recipient + ": " + message); } @Override public double getCost() { return 0.0; } } public class NotificationService { // This method works with ANY notification type — past, present, or future! public void sendAll(Notification[] notifications) { double totalCost = 0; for (Notification n : notifications) { n.send(); // Polymorphic call — each type runs its own send() totalCost += n.getCost(); } System.out.printf("Total cost: $%.3f%n", totalCost); } } public class Main { public static void main(String[] args) { Notification[] batch = { new EmailNotification("Your order shipped!", "alice@email.com", "Order #1234"), new SMSNotification("Code: 7891", "+1-555-0123"), new PushNotification("New message!", "bob_device", "ChatApp"), new EmailNotification("Meeting at 3pm", "team@company.com", "Calendar Reminder"), new SMSNotification("Delivery arriving", "+1-555-0456") }; NotificationService service = new NotificationService(); service.sendAll(batch); } }

Output

📧 Email to alice@email.com | Subject: Order #1234 | Body: Your order shipped!
📱 SMS to +1-555-0123: Code: 7891
🔔 Push [ChatApp] to bob_device: New message!
📧 Email to team@company.com | Subject: Calendar Reminder | Body: Meeting at 3pm
📱 SMS to +1-555-0456: Delivery arriving
Total cost: $0.102

Key insight: NotificationService.sendAll() doesn't know about Email, SMS, or Push specifically. It works with the base Notification type. You can add SlackNotification tomorrow without changing sendAll()!

Upcasting and Downcasting

Upcasting (Child → Parent Reference)

Always safe, implicit:

java example

Dog dog = new Dog("Rex", 3, "Labrador");
Animal animal = dog;  // Upcasting - implicit, always safe

animal.eat();    // ✅ Works - defined in Animal
animal.sleep();  // ✅ Works - defined in Animal
// animal.bark(); // ❌ Compile error - Animal doesn't know about bark()

The object is STILL a Dog in memory. But through the Animal reference, you can only access Animal's interface.

Downcasting (Parent Reference → Child)

Explicit, can fail at runtime:

java example

public class Main {
    public static void main(String[] args) {
        Animal animal = new Dog("Rex", 3, "Labrador");  // Upcast

        // Check before downcasting!
        if (animal instanceof Dog) {
            Dog dog = (Dog) animal;  // Downcast - explicit
            dog.bark();  // ✅ Now we can access Dog methods
        }

        // Without check — DANGEROUS
        Animal cat = new Cat("Whiskers", 2);
        // Dog wrong = (Dog) cat;  // ❌ ClassCastException at runtime!

        // Java 16+ pattern matching
        if (animal instanceof Dog d) {  // Check + cast in one step
            d.bark();
        }
    }
}

Polymorphism with Interfaces

Interfaces provide the purest form of polymorphism:

Example

public interface Sortable { int compareTo(Sortable other); String getLabel(); } public class Student implements Sortable { private String name; private double gpa; public Student(String name, double gpa) { this.name = name; this.gpa = gpa; } @Override public int compareTo(Sortable other) { Student s = (Student) other; return Double.compare(this.gpa, s.gpa); } @Override public String getLabel() { return name + " (GPA: " + gpa + ")"; } } public class Product implements Sortable { private String name; private double price; public Product(String name, double price) { this.name = name; this.price = price; } @Override public int compareTo(Sortable other) { Product p = (Product) other; return Double.compare(this.price, p.price); } @Override public String getLabel() { return name + " ($" + price + ")"; } } // Generic sorting that works with ANYTHING Sortable public class SortUtil { public static void bubbleSort(Sortable[] items) { for (int i = 0; i < items.length - 1; i++) { for (int j = 0; j < items.length - 1 - i; j++) { if (items[j].compareTo(items[j + 1]) > 0) { Sortable temp = items[j]; items[j] = items[j + 1]; items[j + 1] = temp; } } } } public static void printSorted(Sortable[] items) { bubbleSort(items); for (Sortable item : items) { System.out.println(" " + item.getLabel()); } } } public class Main { public static void main(String[] args) { Student[] students = { new Student("Alice", 3.8), new Student("Bob", 3.2), new Student("Charlie", 3.9) }; Product[] products = { new Product("Laptop", 999.99), new Product("Mouse", 29.99), new Product("Keyboard", 79.99) }; System.out.println("Students by GPA:"); SortUtil.printSorted(students); System.out.println("Products by price:"); SortUtil.printSorted(products); } }

Output

Students by GPA:
  Bob (GPA: 3.2)
  Alice (GPA: 3.8)
  Charlie (GPA: 3.9)
Products by price:
  Mouse ($29.99)
  Keyboard ($79.99)
  Laptop ($999.99)

Polymorphism in Collections

java example

import java.util.*;

public class Main {
    public static void main(String[] args) {
        // List of different shapes - all treated as Shape
        List<Shape> canvas = new ArrayList<>();
        canvas.add(new Circle(5, "Red"));
        canvas.add(new Rectangle(4, 6, "Blue"));
        canvas.add(new Triangle(3, 4, 5, "Green"));
        canvas.add(new Circle(2, "Yellow"));

        // Polymorphic operations
        double totalArea = 0;
        for (Shape shape : canvas) {
            System.out.printf("%s - Area: %.2f%n", shape.getClass().getSimpleName(), shape.area());
            totalArea += shape.area();
        }
        System.out.printf("Total canvas area: %.2f%n", totalArea);
    }
}

The Power: Open/Closed Principle

Polymorphism enables the Open/Closed Principle — code is open for extension but closed for modification:

Example

// This processor NEVER needs to change when you add new file types public class FileProcessor { public void processAll(List<FileHandler> handlers, String filename) { for (FileHandler handler : handlers) { if (handler.canHandle(filename)) { handler.process(filename); return; } } System.out.println("No handler found for: " + filename); } } public interface FileHandler { boolean canHandle(String filename); void process(String filename); } // Add new types without changing FileProcessor public class PdfHandler implements FileHandler { @Override public boolean canHandle(String filename) { return filename.endsWith(".pdf"); } @Override public void process(String filename) { System.out.println("Processing PDF: " + filename); } } public class ImageHandler implements FileHandler { @Override public boolean canHandle(String filename) { return filename.endsWith(".jpg") || filename.endsWith(".png"); } @Override public void process(String filename) { System.out.println("Processing image: " + filename); } }

Common Mistakes

Assuming the reference type determines behavior:

``java Animal a = new Dog(); a.makeSound(); // Calls Dog's version, NOT Animal's! ``

Forgetting that fields are NOT polymorphic:

```java class Parent { String name = "Parent"; } class Child extends Parent { String name = "Child"; }

Parent p = new Child(); System.out.println(p.name); // "Parent" — fields use reference type! ```

Unsafe downcasting:

``java Animal a = new Cat(); Dog d = (Dog) a; // ❌ ClassCastException! Cat is not a Dog ``

Overloading when you mean overriding:

``java class Child extends Parent { // This is OVERLOADING (different params), not overriding! public void process(String s, int x) { } // Parent has: public void process(String s) { } } ``

Best Practices

Program to interfaces/abstractions, not concrete types
Use polymorphism to eliminate if-else chains and switch on type
Prefer runtime polymorphism for extensibility
Always use @Override to catch overloading-by-mistake
Check with instanceof before downcasting
Design class hierarchies for polymorphic use from the start

Interview Questions

Q1: What is polymorphism? The ability of a single interface to represent different underlying types. Same method name, different behavior depending on the actual object.

Q2: Difference between compile-time and runtime polymorphism? Compile-time: method overloading, resolved by compiler based on argument types. Runtime: method overriding, resolved by JVM based on actual object type.

Q3: Can polymorphism work with fields? No. Only methods are polymorphic. Field access uses the reference type, not the object type.

Q4: What is the advantage of polymorphism? Extensibility — you can add new types without modifying existing code. The processing code works with the base type and automatically handles all subtypes.

Q5: What is dynamic method dispatch? The JVM mechanism that determines at runtime which overridden method to call based on the actual object pointed to by the reference.

Q6: Can you achieve polymorphism without inheritance? Yes, through interfaces. A class can implement an interface and be used polymorphically through that interface reference.

Q7: What is parametric polymorphism in Java? Generics. List<T> works with any type T — that's parametric polymorphism. The same code structure operates on different types.

Q8: What is upcasting and downcasting in Java? Upcasting: assigning child object to parent reference (Animal a = new Dog()). Always safe, happens implicitly. Downcasting: casting parent reference back to child (Dog d = (Dog) a). Risky, requires explicit cast, can throw ClassCastException if the actual object isn't compatible.

Q9: How does polymorphism work with method overloading? Method overloading is compile-time polymorphism — the compiler decides which overloaded version to call based on argument types at compile time. This is also called static binding or early binding. No runtime decision is involved.

Q10: What is the instanceof operator and when is it used with polymorphism? instanceof checks the actual runtime type of an object: if (animal instanceof Dog). It's used before downcasting to avoid ClassCastException. With Java 16+ pattern matching: if (animal instanceof Dog d) combines check and cast.

Q11: Can constructors be polymorphic? No. Constructors are not inherited and cannot be overridden, so they cannot be polymorphic. When you call new Dog(), you always get a Dog constructor — there's no dynamic dispatch for constructors.

Q12: How does polymorphism enable the Open/Closed Principle? With polymorphism, you can add new subclasses without modifying existing code. A method accepting Shape works with any new shape subclass (Circle, Triangle, etc.) without changes. The code is "open for extension" (new shapes) but "closed for modification" (existing code unchanged).

Exam Focus

Revise definitions, diagrams, examples, and short-answer points for Polymorphism in Java.

Interview Use

Prepare one clear explanation, one practical example, and one common mistake for this Java Master Course topic.

Search Terms

java-master-course, java master course, java, master, course, oops, polymorphism, polymorphism in java

Continue learning this concept

OOPsAbstract Class in JavaComplete guide to abstract classes in Java — abstract methods, partial implementation, when to use abstract classes, template method pattern, and abstract class vs interface comparison.OOPsAbstraction in JavaComplete guide to abstraction in Java — hiding complexity, abstract classes and interfaces, abstraction layers, real-world design, and achieving loose coupling through abstraction.OOPsAnonymous Class in JavaComplete guide to anonymous classes in Java — creating inline implementations, event handlers, comparators, and understanding when lambdas replaced anonymous classes.OOPsClass and Object in JavaDeep dive into Java classes and objects — class anatomy, object creation, memory allocation, instance vs class members, and how objects work under the hood in the JVM.OOPsConstructor in JavaComplete guide to Java constructors — default, parameterized, copy constructors, constructor chaining, overloading, and the role of constructors in object initialization.OOPsEncapsulation in JavaComplete guide to encapsulation in Java — access modifiers, getters and setters, data hiding, immutable classes, and building robust protected object state.

PreviousOOPs Introduction Nextstatic Keyword in Java

Java Notes

Polymorphism in Java

Complete guide to polymorphism in Java — compile-time vs runtime polymorphism, method dispatch, upcasting, downcasting, and designing extensible systems with polymorphic code.

Polymorphism is arguably the most powerful OOP concept. It lets you write flexible, extensible code that works with objects you haven't even created yet.

Two Types of Polymorphism

Type	Mechanism	Binding	Also Called
Compile-time	Method Overloading	Static (compile time)	Static Polymorphism
Runtime	Method Overriding	Dynamic (runtime)	Dynamic Polymorphism

Compile-Time Polymorphism (Overloading)

The compiler decides which method to call based on the argument types:

java example

public class Calculator {
    public int calculate(int a, int b) {
        return a + b;
    }

    public double calculate(double a, double b) {
        return a + b;
    }

    public int calculate(int a, int b, int c) {
        return a + b + c;
    }

    public String calculate(String a, String b) {
        return a + b;  // String concatenation
    }
}

public class Main {
    public static void main(String[] args) {
        Calculator calc = new Calculator();
        System.out.println(calc.calculate(5, 3));           // int version
        System.out.println(calc.calculate(2.5, 3.7));       // double version
        System.out.println(calc.calculate(1, 2, 3));        // three-param version
        System.out.println(calc.calculate("Hello", " World")); // String version
    }
}

Output

8
6.2
6
Hello World

Runtime Polymorphism (Overriding)

The JVM decides which method to call based on the actual object type at runtime. This is the real power:

Example

Output

📧 Email to alice@email.com | Subject: Order #1234 | Body: Your order shipped!
📱 SMS to +1-555-0123: Code: 7891
🔔 Push [ChatApp] to bob_device: New message!
📧 Email to team@company.com | Subject: Calendar Reminder | Body: Meeting at 3pm
📱 SMS to +1-555-0456: Delivery arriving
Total cost: $0.102

Upcasting and Downcasting

Upcasting (Child → Parent Reference)

Always safe, implicit:

java example

Dog dog = new Dog("Rex", 3, "Labrador");
Animal animal = dog;  // Upcasting - implicit, always safe

animal.eat();    // ✅ Works - defined in Animal
animal.sleep();  // ✅ Works - defined in Animal
// animal.bark(); // ❌ Compile error - Animal doesn't know about bark()

The object is STILL a Dog in memory. But through the Animal reference, you can only access Animal's interface.

Downcasting (Parent Reference → Child)

Explicit, can fail at runtime:

java example

public class Main {
    public static void main(String[] args) {
        Animal animal = new Dog("Rex", 3, "Labrador");  // Upcast

        // Check before downcasting!
        if (animal instanceof Dog) {
            Dog dog = (Dog) animal;  // Downcast - explicit
            dog.bark();  // ✅ Now we can access Dog methods
        }

        // Without check — DANGEROUS
        Animal cat = new Cat("Whiskers", 2);
        // Dog wrong = (Dog) cat;  // ❌ ClassCastException at runtime!

        // Java 16+ pattern matching
        if (animal instanceof Dog d) {  // Check + cast in one step
            d.bark();
        }
    }
}

Polymorphism with Interfaces

Interfaces provide the purest form of polymorphism:

Example

Output

Students by GPA:
  Bob (GPA: 3.2)
  Alice (GPA: 3.8)
  Charlie (GPA: 3.9)
Products by price:
  Mouse ($29.99)
  Keyboard ($79.99)
  Laptop ($999.99)

Polymorphism in Collections

java example

import java.util.*;

public class Main {
    public static void main(String[] args) {
        // List of different shapes - all treated as Shape
        List<Shape> canvas = new ArrayList<>();
        canvas.add(new Circle(5, "Red"));
        canvas.add(new Rectangle(4, 6, "Blue"));
        canvas.add(new Triangle(3, 4, 5, "Green"));
        canvas.add(new Circle(2, "Yellow"));

        // Polymorphic operations
        double totalArea = 0;
        for (Shape shape : canvas) {
            System.out.printf("%s - Area: %.2f%n", shape.getClass().getSimpleName(), shape.area());
            totalArea += shape.area();
        }
        System.out.printf("Total canvas area: %.2f%n", totalArea);
    }
}

The Power: Open/Closed Principle

Polymorphism enables the Open/Closed Principle — code is open for extension but closed for modification:

Example

Common Mistakes

Assuming the reference type determines behavior:

``java Animal a = new Dog(); a.makeSound(); // Calls Dog's version, NOT Animal's! ``

Forgetting that fields are NOT polymorphic:

```java class Parent { String name = "Parent"; } class Child extends Parent { String name = "Child"; }

Parent p = new Child(); System.out.println(p.name); // "Parent" — fields use reference type! ```

Unsafe downcasting:

``java Animal a = new Cat(); Dog d = (Dog) a; // ❌ ClassCastException! Cat is not a Dog ``

Overloading when you mean overriding:

``java class Child extends Parent { // This is OVERLOADING (different params), not overriding! public void process(String s, int x) { } // Parent has: public void process(String s) { } } ``

Best Practices

Program to interfaces/abstractions, not concrete types
Use polymorphism to eliminate if-else chains and switch on type
Prefer runtime polymorphism for extensibility
Always use @Override to catch overloading-by-mistake
Check with instanceof before downcasting
Design class hierarchies for polymorphic use from the start

Interview Questions

Q1: What is polymorphism? The ability of a single interface to represent different underlying types. Same method name, different behavior depending on the actual object.

Q3: Can polymorphism work with fields? No. Only methods are polymorphic. Field access uses the reference type, not the object type.

Q5: What is dynamic method dispatch? The JVM mechanism that determines at runtime which overridden method to call based on the actual object pointed to by the reference.

Q6: Can you achieve polymorphism without inheritance? Yes, through interfaces. A class can implement an interface and be used polymorphically through that interface reference.

Q7: What is parametric polymorphism in Java? Generics. List<T> works with any type T — that's parametric polymorphism. The same code structure operates on different types.

Exam Focus

Revise definitions, diagrams, examples, and short-answer points for Polymorphism in Java.

Interview Use

Prepare one clear explanation, one practical example, and one common mistake for this Java Master Course topic.

Search Terms

java-master-course, java master course, java, master, course, oops, polymorphism, polymorphism in java

Continue learning this concept

PreviousOOPs Introduction Nextstatic Keyword in Java