Why polymorphism is needed in Java - Visual Breakdown

Concept Flow - Why polymorphism is needed

Define base class

↓

Create subclasses

↓

Use base class reference

↓

Call overridden method

↓

Actual subclass method runs

↓

Flexible and reusable code

Polymorphism lets us use a base class reference to call methods that behave differently depending on the subclass, making code flexible and reusable.

Execution Sample

Java

class Animal {
  void sound() { System.out.println("Animal sound"); }
}
class Dog extends Animal {
  void sound() { System.out.println("Bark"); }
}
public class Main {
  public static void main(String[] args) {
    Animal a = new Dog();
    a.sound();
  }
}

This code shows a base class Animal and a subclass Dog overriding the sound method. The Animal reference calls Dog's sound.

Execution Table

Step	Action	Object Type	Method Called	Output
1	Create Animal object	Animal	-	-
2	Create Dog object	Dog	-	-
3	Assign Dog object to Animal reference	Dog	-	-
4	Call sound() on Animal reference holding Dog	Dog	sound()	Bark
5	End	-	-	-

💡 Execution stops after calling sound() on Animal reference holding Dog object, demonstrating polymorphism.

Variable Tracker

Variable	Start	After Step 2	After Step 3	Final
a	null	null	Dog object	Dog object

Key Moments - 2 Insights

Why does calling sound() on an Animal reference run Dog's sound() method?

Because the actual object is Dog, Java uses the object's method at runtime (see execution_table step 4). This is polymorphism.

Why can't we call Dog-specific methods using the Animal reference?

Animal reference only knows methods declared in Animal. Dog-specific methods are not accessible unless cast (not shown here).

Visual Quiz - 3 Questions

Look at the execution_table, what is the output at step 4?

A Animal sound

B No output

C Bark

D Compilation error

💡 Hint

Check the 'Output' column at step 4 in execution_table.

At which step is the Animal reference assigned a Dog object?

A Step 1

B Step 3

C Step 2

D Step 4

💡 Hint

Look at the 'Action' column describing assignment in execution_table.

If we create a Cat subclass overriding sound(), what changes in the execution_table?

A Output at step 4 changes to Cat's sound

B No change, still Dog's sound

C Compilation error

D Animal sound output

💡 Hint

Polymorphism calls the actual object's method, so output depends on the object type.

Concept Snapshot

Polymorphism allows a base class reference to call overridden methods in subclasses.
It enables flexible, reusable code by deciding method behavior at runtime.
Use base class type to refer to subclass objects.
Method calls run subclass versions if overridden.
This avoids code duplication and supports easy extension.

Full Transcript

Polymorphism in Java means using a base class reference to call methods that behave differently depending on the actual subclass object. In the example, an Animal reference points to a Dog object. When calling sound(), Dog's version runs, not Animal's. This happens because Java decides which method to run at runtime based on the object's real type. This feature helps write flexible and reusable code. You can add new subclasses without changing existing code that uses the base class. However, the base class reference can only call methods declared in the base class, not subclass-specific methods. This example shows why polymorphism is needed: it lets one reference type work with many object types, each behaving correctly.