Polymorphism – Overriding and Dynamic Binding in Java

Table of Contents

1. Introduction to Polymorphism
2. Types of Polymorphism
   • Compile-time Polymorphism (Method Overloading)
   • Runtime Polymorphism (Method Overriding)
3. Method Overriding
4. Dynamic Binding
5. Benefits of Polymorphism
6. Polymorphism in Action: Examples
7. Common Pitfalls and Best Practices
8. Summary

1. Introduction to Polymorphism

Polymorphism is another core principle of object-oriented programming (OOP), along with encapsulation, inheritance, and abstraction. Derived from the Greek words “poly” (many) and “morph” (forms), polymorphism allows one object to take many forms.

In the context of Java, polymorphism allows an object to behave in multiple ways based on the method call, either by overloading methods at compile-time or overriding them at runtime. In this module, we will focus on runtime polymorphism, achieved through method overriding and dynamic binding.

2. Types of Polymorphism

a. Compile-time Polymorphism (Method Overloading)

Compile-time polymorphism refers to method overloading, where multiple methods in a class can have the same name but different parameters (either in number or type). The decision of which method to invoke is made at compile time.

Example of method overloading:

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

    double add(double a, double b) {
        return a + b;
    }
}

Here, the method add is overloaded with two versions: one for integers and one for doubles. The compiler decides which method to call based on the arguments passed.

b. Runtime Polymorphism (Method Overriding)

Runtime polymorphism, also known as dynamic polymorphism, happens when a subclass provides a specific implementation of a method that is already defined in its superclass. The specific method to call is determined at runtime.

3. Method Overriding

Method overriding occurs when a subclass provides its own implementation of a method that is already defined in its parent class, but with the same method signature (name, return type, and parameters).

The method in the parent class is called a base method, and the method in the subclass is called an overridden method. The overriding method provides its own definition, which replaces the inherited version when the method is called on the object of the subclass.

Example:

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

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

public class Main {
    public static void main(String[] args) {
        Animal animal = new Dog(); // Upcasting
        animal.sound();  // Calls Dog's overridden sound method
    }
}

In this example:

• Dog overrides the sound method of Animal.
• The sound method called on an Animal reference (which points to a Dog object) invokes the Dog’s overridden method, not the parent class version.

4. Dynamic Binding

Dynamic binding (or late binding) refers to the runtime decision-making process of selecting the method to be invoked. When a method is called on an object, the JVM determines which method to invoke based on the actual object type (not the reference type) at runtime.

In the example above, the reference type is Animal, but the object type is Dog. Since Dog overrides the sound method, the JVM dynamically binds the method call to Dog‘s version of sound at runtime.

This mechanism is what allows polymorphic behavior in Java. The method invocation happens based on the actual object that the reference points to, even if the reference is of a superclass type.

Dynamic Binding Example:

class Shape {
    void draw() {
        System.out.println("Drawing a generic shape");
    }
}

class Circle extends Shape {
    @Override
    void draw() {
        System.out.println("Drawing a circle");
    }
}

class Square extends Shape {
    @Override
    void draw() {
        System.out.println("Drawing a square");
    }
}

public class Main {
    public static void main(String[] args) {
        Shape shape1 = new Circle();  // Upcasting
        Shape shape2 = new Square();  // Upcasting
        
        shape1.draw();  // Circle's draw method
        shape2.draw();  // Square's draw method
    }
}

In the code above:

• shape1 is a reference of type Shape but holds a Circle object.
• shape2 is a reference of type Shape but holds a Square object.
• The draw method is invoked polymorphically, and the actual method executed is based on the object type (Circle or Square), not the reference type (Shape).

This dynamic method invocation is a core feature of polymorphism in Java.

5. Benefits of Polymorphism

Polymorphism provides several benefits, particularly in the context of object-oriented design and development:

1. Flexibility: It allows one interface to be used for different underlying forms of data. This is particularly useful when you need to write code that can work with objects of different classes.
2. Code Reusability: You can write more generic code, as a superclass reference can point to objects of any subclass, thus minimizing redundancy.
3. Ease of Maintenance: Modifying the behavior of a subclass method does not affect the rest of the program as long as the method signature remains the same.
4. Decoupling: Polymorphism decouples the class behavior, making the codebase easier to understand and modify.

6. Polymorphism in Action: Examples

Example 1: Employee Class Hierarchy

Let’s consider a real-world example of an employee hierarchy:

abstract class Employee {
    abstract void work();
}

class Developer extends Employee {
    @Override
    void work() {
        System.out.println("Writing code");
    }
}

class Manager extends Employee {
    @Override
    void work() {
        System.out.println("Managing the team");
    }
}

public class Main {
    public static void main(String[] args) {
        Employee emp1 = new Developer();  // Developer object
        Employee emp2 = new Manager();    // Manager object

        emp1.work();  // Calls Developer's work method
        emp2.work();  // Calls Manager's work method
    }
}

In this example:

• Employee is an abstract class with an abstract method work().
• Developer and Manager are subclasses that override work().
• At runtime, based on the actual object (Developer or Manager), the appropriate work() method is called.

Example 2: Payment System

Consider a payment system where different types of payment methods (credit card, PayPal, etc.) are used:

class Payment {
    void pay() {
        System.out.println("Making a payment");
    }
}

class CreditCardPayment extends Payment {
    @Override
    void pay() {
        System.out.println("Paying with Credit Card");
    }
}

class PayPalPayment extends Payment {
    @Override
    void pay() {
        System.out.println("Paying with PayPal");
    }
}

public class Main {
    public static void main(String[] args) {
        Payment payment1 = new CreditCardPayment();  // CreditCardPayment object
        Payment payment2 = new PayPalPayment();     // PayPalPayment object

        payment1.pay();  // Calls CreditCardPayment's pay method
        payment2.pay();  // Calls PayPalPayment's pay method
    }
}

This example shows how polymorphism allows different types of payments to be processed through a common interface, which enhances flexibility and scalability.

7. Common Pitfalls and Best Practices

Pitfalls

• Incorrect Method Signature: The overridden method in the subclass must have the same method signature (name, return type, and parameters) as the method in the superclass.
• Overriding Non-Overridable Methods: You cannot override final, static, or private methods, as they are not subject to polymorphism.
• Casting Issues: Misusing references (incorrect casting) can lead to ClassCastException.

Best Practices

• Always use the @Override annotation when overriding a method. This improves readability and helps catch errors at compile time.
• Avoid deep inheritance hierarchies; prefer interface-based polymorphism when possible.
• Be cautious when using polymorphism in performance-critical sections of code, as dynamic binding can introduce overhead.

8. Summary

In this module, you have learned about polymorphism, particularly method overriding and dynamic binding, which are key features of runtime polymorphism. These mechanisms allow Java to execute the appropriate method based on the actual object type at runtime, providing flexibility, scalability, and ease of maintenance in object-oriented design.

By leveraging polymorphism, you can write more generic, reusable, and maintainable code, enhancing both design and performance in larger applications.