Why polymorphism is needed in Java - See It in Action

Why Polymorphism is Needed in Java

📖 Scenario: Imagine you are building a simple program to manage different types of animals in a zoo. Each animal can make a sound, but the sound is different for each animal. You want to write code that can handle any animal without changing the main program every time you add a new animal.

🎯 Goal: Build a Java program that shows why polymorphism is needed by creating a base class and subclasses with different behaviors, then using polymorphism to call the correct behavior without changing the main code.

📋 What You'll Learn

Create a base class called Animal with a method makeSound().

Create two subclasses Dog and Cat that override makeSound() with their own sounds.

Create a list of Animal objects containing both Dog and Cat.

Use a for loop to call makeSound() on each animal in the list.

Print the sounds to show polymorphism in action.

💡 Why This Matters

🌍 Real World

Polymorphism is used in many software systems to handle different types of objects through a common interface, like different payment methods in an app or different shapes in a drawing program.

💼 Career

Understanding polymorphism is essential for Java developers to write clean, maintainable, and scalable code that can easily adapt to new requirements.

1

Create the base class Animal

Create a class called Animal with a method makeSound() that prints "Some sound".

Java

class Animal {
    void makeSound() {
        // Your code here
    }
}

Hint

The makeSound() method should print a generic sound.

2

Create subclasses Dog and Cat overriding makeSound()

Create classes Dog and Cat that extend Animal. Override makeSound() in Dog to print "Woof" and in Cat to print "Meow".

Java

class Animal {
    void makeSound() {
        System.out.println("Some sound");
    }
}

// Your code here

Hint

Use extends Animal to create subclasses and override makeSound() with @Override.

3

Create a list of Animal objects with Dog and Cat

Create a List<Animal> called animals and add new Dog() and Cat() objects to it.

Java

import java.util.List;
import java.util.ArrayList;

class Animal {
    void makeSound() {
        System.out.println("Some sound");
    }
}

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

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

public class Main {
    public static void main(String[] args) {
        // Your code here
    }
}

Hint

Use List<Animal> and new ArrayList<>() to create the list, then add the objects.

4

Use polymorphism to call makeSound() on each animal

Use a for loop with variable animal to go through animals and call animal.makeSound(). Print the sounds to show polymorphism.

Java

import java.util.List;
import java.util.ArrayList;

class Animal {
    void makeSound() {
        System.out.println("Some sound");
    }
}

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

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

public class Main {
    public static void main(String[] args) {
        List animals = new ArrayList();
        animals.add(new Dog());
        animals.add(new Cat());

        // Your code here
    }
}

Hint

Use a for loop with Animal animal : animals and call animal.makeSound().

Practice

1. Why is polymorphism needed in Java programming?

easy

A. To allow one interface to be used for different data types

B. To increase the speed of the program execution

C. To reduce the size of the compiled code

D. To make the program run only on specific devices

Solution

1. Step 1: Understand polymorphism concept

   Polymorphism means one name can represent many forms, especially methods or objects.

2. Step 2: Identify its purpose in Java

   It allows writing code that works with different types through a common interface.

3. Final Answer:

   To allow one interface to be used for different data types -> Option A

4. Quick Check:

   Polymorphism = One interface, many types [OK]

Hint: Polymorphism means one name, many forms [OK]

Common Mistakes:

• Thinking polymorphism speeds up execution
• Confusing polymorphism with code size reduction
• Believing it limits device compatibility

2. Which of the following Java code snippets correctly demonstrates polymorphism?

easy

A. Dog d = new Animal(); d.sound();

B. Dog d = new Dog(); d.bark();

C. Animal a = new Animal(); a.sound();

D. Animal a = new Dog(); a.sound();

Solution

1. Step 1: Check object assignment compatibility

   Polymorphism allows a superclass reference to point to a subclass object, like Animal a = new Dog();

2. Step 2: Verify method call correctness

   Calling a method on the superclass reference that is overridden in subclass shows polymorphism.

3. Final Answer:

   Animal a = new Dog(); a.sound(); -> Option D

4. Quick Check:

   Superclass ref to subclass object = polymorphism [OK]

Hint: Superclass reference can hold subclass object [OK]

Common Mistakes:

• Assigning superclass object to subclass reference
• Using subclass-specific methods on superclass reference
• Ignoring method overriding in polymorphism

3. What will be the output of the following Java code?

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

medium

A. Animal sound

B. Compilation error

C. Dog barks

D. Runtime error

Solution

1. Step 1: Identify polymorphic call

   Variable 'a' is of type Animal but refers to a Dog object.

2. Step 2: Determine method execution

   At runtime, Dog's overridden sound() method is called, printing "Dog barks".

3. Final Answer:

   Dog barks -> Option C

4. Quick Check:

   Overridden method runs based on object type [OK]

Hint: Method called depends on actual object, not reference type [OK]

Common Mistakes:

• Expecting superclass method output
• Confusing compile-time and runtime method binding
• Thinking code causes errors

4. Identify the error in this Java code related to polymorphism:

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

medium

A. Cannot assign Dog object to Animal reference

B. Method bark() is not found in Animal class

C. Missing override annotation

D. No error, code runs fine

Solution

1. Step 1: Check reference type methods

   Variable 'a' is of type Animal, which does not have method bark().

2. Step 2: Understand method call rules

   At compile time, only methods in Animal class are accessible via 'a'. bark() is undefined there.

3. Final Answer:

   Method bark() is not found in Animal class -> Option B

4. Quick Check:

   Reference type limits accessible methods [OK]

Hint: Reference type decides accessible methods [OK]

Common Mistakes:

• Thinking subclass methods are always accessible
• Ignoring compile-time method checking
• Assuming override annotation is mandatory

5. How does polymorphism help in maintaining and extending Java programs?

hard

A. By allowing new classes to be added with minimal changes to existing code

B. By forcing all classes to have the same methods with identical code

C. By preventing any changes once the program is written

D. By making the program run faster on all machines

Solution

1. Step 1: Understand polymorphism's role in code flexibility

   Polymorphism allows new subclasses to be created that fit existing interfaces.

2. Step 2: See how it affects maintenance and extension

   Existing code can use new classes without modification, making programs easier to grow and maintain.

3. Final Answer:

   By allowing new classes to be added with minimal changes to existing code -> Option A

4. Quick Check:

   Polymorphism enables easy extension [OK]

Hint: Polymorphism means add new classes without changing old code [OK]

Common Mistakes:

• Thinking polymorphism forces identical method code
• Believing it stops program changes
• Assuming it improves speed directly