Java Polymorphism

Java Polymorphism

Polymorphism means "many forms", and it occurs when we have many classes that are related to each other by inheritance.

Like we specified in the previous chapter; Inheritance lets us inherit attributes and methods from another class. Polymorphism uses those methods to perform different tasks. This allows us to perform a single action in different ways.

For example, think of a superclass called Animal that has a method called animalSound(). Subclasses of Animals could be Pigs, Cats, Dogs, Birds - And they also have their own implementation of an animal sound (the pig oinks, and the cat meows, etc.).

Why Use Polymorphism?

Polymorphism is useful for code reusability: reuse attributes and methods of an existing class when you create a new class. It also allows you to treat objects of different classes in a uniform way.

Polymorphism Example

In this example, we have a base class Animal and two subclasses, Pig and Dog. They all have a method animalSound(), but it is implemented differently in each subclass. This is called method overriding.

class Animal {
  public void animalSound() {
    System.out.println("The animal makes a sound");
  }
}

class Pig extends Animal {
  // Method overriding
  public void animalSound() {
    System.out.println("The pig says: wee wee");
  }
}
class Dog extends Animal {
  // Method overriding
  public void animalSound() {
    System.out.println("The dog says: bow wow");
  }
}
class Main {
  public static void main(String[] args) {
    Animal myAnimal = new Animal();  // Create a Animal object
    Animal myPig = new Pig();  // Create a Pig object
    Animal myDog = new Dog();  // Create a Dog object
    myAnimal.animalSound();
    myPig.animalSound();
    myDog.animalSound();
  }
}

Notice that even though myPig and myDog are declared as type Animal, the Java Virtual Machine (JVM) knows their actual object type at runtime (Pig and Dog) and calls the correct overridden method. This is called runtime polymorphism or dynamic method dispatch.