Java Language - 19 - Method Overriding

Object-Oriented Programming (OOP) – Method Overriding

Introduction

Method overriding is a fundamental concept in object-oriented programming (OOP) that allows a subclass to provide a specific implementation for a method that is already defined in its superclass. It enables the creation of more specialized behavior in derived classes while maintaining a consistent interface. In this guide, we’ll explore the concept of method overriding in Java and its practical applications.

What is Method Overriding?

Method overriding is a type of polymorphism that occurs when a subclass provides a specific implementation for a method inherited from its superclass. In Java, the overridden method in the subclass has the same name, return type, and parameter list as the method in the superclass.

Method Overriding in Action

Consider a scenario where you have a base class ‘Shape’ with a method ‘area’ to calculate the area of different shapes. You can then create specialized shapes like ‘Circle’ and ‘Rectangle’ that override the ‘area’ method to provide their own implementations:


class Shape {
    double area() {
        return 0.0; // Default implementation for unknown shapes
    }
}

class Circle extends Shape {
    double radius;

    Circle(double radius) {
        this.radius = radius;
    }

    @Override
    double area() {
        return Math.PI * radius * radius; // Specific implementation for circles
    }
}

class Rectangle extends Shape {
    double width;
    double height;

    Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }

    @Override
    double area() {
        return width * height; // Specific implementation for rectangles
    }
}

In this example, ‘Circle’ and ‘Rectangle’ are subclasses of ‘Shape’ and override the ‘area’ method to provide their own area calculation logic. The ‘@Override’ annotation indicates that these methods are intended to override the superclass method.

Rules for Method Overriding

Method overriding in Java follows several rules to ensure correctness and maintain the integrity of the class hierarchy:

Method Signature: The overriding method must have the same name, return type, and parameter list as the overridden method.
Access Modifier: The access modifier of the overriding method cannot be more restrictive than the overridden method. For example, if the superclass method is ‘public,’ the overriding method must also be ‘public’ or ‘protected.’
Exception Handling: The overriding method can throw the same, subclass, or no exceptions as the overridden method. It cannot throw broader exceptions.

Superclass and Subclass Relationship

Method overriding is closely related to the relationship between a superclass and its subclasses. In the example above, ‘Circle’ and ‘Rectangle’ are subclasses of ‘Shape.’ When you invoke the ‘area’ method on an object of the subclass, the overridden method in the subclass is executed.

Dynamic Method Dispatch

Method overriding plays a crucial role in enabling dynamic method dispatch, a concept where the method to be executed is determined at runtime based on the actual object’s type. This allows you to write more flexible and extensible code.


Shape shape1 = new Circle(5.0);
Shape shape2 = new Rectangle(4.0, 6.0);

double area1 = shape1.area(); // Calls the 'area' method of Circle
double area2 = shape2.area(); // Calls the 'area' method of Rectangle

In this code, ‘shape1’ and ‘shape2’ are declared as ‘Shape’ but hold instances of ‘Circle’ and ‘Rectangle.’ When you call the ‘area’ method on these objects, the appropriate overridden method in the respective subclasses is executed.

Benefits of Method Overriding

Method overriding offers several advantages in Java and OOP, including:

Polymorphism: It enables polymorphic behavior, where the same method name can have different implementations in various subclasses.
Specialization: It allows you to create specialized behavior in subclasses while maintaining a consistent interface defined in the superclass.
Extensibility: It makes your code more extensible and adaptable to new requirements by adding new subclasses with their own implementations.

Conclusion

Method overriding is a crucial concept in Java and OOP that promotes polymorphism and specialization. It enables subclasses to provide specific implementations for methods inherited from their superclass, making your code more flexible and extensible.

Java Language – 19 – Method Overriding