Java Method Overriding

Blog Banner for Java Method Overriding

Introduction:

Java, being one of the most popular programming languages, offers powerful object-oriented programming (OOP) features. One such feature is method overriding, which allows a subclass to provide its own implementation of a method inherited from its superclass. This essential concept of OOP helps in achieving polymorphism and enables the creation of flexible and extensible code. In this blog post, we will delve into the depths of Java method overriding, exploring its syntax, rules, best practices, and examples.

Understanding Method Overriding:

Method overriding is a fundamental concept in Java's inheritance mechanism, where a subclass provides its implementation of a method already defined in its superclass. By doing so, the subclass can extend or modify the behavior of the inherited method according to its specific requirements.

Syntax:

To override a method, the subclass must follow a specific syntax:

class Superclass {
    // Method to be overridden
    public void methodName() {
        // Method implementation
    }
}

class Subclass extends Superclass {
    // Overriding the method
    @Override
    public void methodName() {
        // New implementation
    }
}

Key Points to Remember:

1. The method in the subclass must have the same name, return type, and parameters (if any) as the method in the superclass.

2. The method in the subclass must have the same or wider access modifier compared to the method in the superclass.

3. The `@Override` annotation is not mandatory but is considered a good practice. It helps detect errors during compilation if the overriding is incorrect.

Rules for Method Overriding:

1. Inheritance: Overriding is only applicable when a subclass inherits a method from its superclass.

2. Signature: The method in the subclass must have the same method signature as the method in the superclass.

3. Access Modifiers: The access modifier of the overridden method in the subclass must be the same or less restrictive than the access modifier of the superclass method.

4. Return Type: The return type of the overridden method in the subclass must be the same or a subtype (covariant return type) of the return type in the superclass.

5. Exceptions: The subclass method can only declare the same or narrower exceptions than the superclass method. It is also possible to declare no exceptions at all.

6. Static Methods: Static methods cannot be overridden as they belong to the class, not the instance. They can only be shadowed.

Access Specifiers in Method Overriding:

Access specifiers in method overriding play a crucial role in determining the visibility and accessibility of overridden methods in Java. The access specifiers control the level of access that subclasses have to the superclass's methods. Let's explore the different scenarios and rules regarding access specifiers in method overriding.

1. Public Access Specifier:

When a method in the superclass is declared with the `public` access specifier, the overriding method in the subclass can have the same or wider access modifier. This means that the overriding method can be declared as `public` or `protected` but not as `private`.

Example:

class Superclass {
    public void methodName() {
        // Method implementation
    }
}

class Subclass extends Superclass {
    @Override
    public void methodName() {
        // New implementation
    }
}

2. Protected Access Specifier:

If the superclass's method has the `protected` access specifier, the overriding method in the subclass can have the same or wider access modifier. It can be declared as `protected` or `public` but not as `private`.

Example:

class Superclass {
    protected void methodName() {
        // Method implementation
    }
}

class Subclass extends Superclass {
    @Override
    protected void methodName() {
        // New implementation
    }
}

3. Default (Package-Private) Access Specifier:

When a method in the superclass does not specify any access modifier (default access, also known as package-private), the overriding method in the subclass can have the same or wider access modifier. It can be declared as default (package-private), `protected`, or `public` but not as `private`.

Example:

class Superclass {
    void methodName() {
        // Method implementation
    }
}

class Subclass extends Superclass {
    @Override
    void methodName() {
        // New implementation
    }
}

4. Private Access Specifier:

Methods declared with the `private` access specifier in the superclass are not accessible to subclasses and cannot be overridden. Therefore, it is not possible to override a `private` method in the superclass.

Example:

class Superclass {
    private void methodName() {
        // Method implementation
    }
}

class Subclass extends Superclass {
    // Cannot override private method from superclass
}

It's important to note that when overriding a method, the access specifier must be the same or less restrictive in the subclass. This rule ensures that the subclass does not violate encapsulation by exposing more accessible methods than the superclass.

Certainly! Here's an example that demonstrates method overriding with different access specifiers, including `public`, `protected`, `default (package-private)`, and `private`:

class Superclass {
    public void publicMethod() {
        System.out.println("This is a public method.");
    }

    protected void protectedMethod() {
        System.out.println("This is a protected method.");
    }

    void defaultMethod() {
        System.out.println("This is a default method (package-private).");
    }

    private void privateMethod() {
        System.out.println("This is a private method.");
    }
}

class Subclass extends Superclass {
    @Override
    public void publicMethod() {
        System.out.println("This is the overridden public method.");
    }

    @Override
    protected void protectedMethod() {
        System.out.println("This is the overridden protected method.");
    }

    @Override
    void defaultMethod() {
        System.out.println("This is the overridden default method (package-private).");
    }

    // Attempting to override the private method will result in a compilation error
}

public class Main {
    public static void main(String[] args) {
        Subclass subclass = new Subclass();

        subclass.publicMethod();
        subclass.protectedMethod();
        subclass.defaultMethod();
    }
}

In this example, we have a `Superclass` with methods declared with different access specifiers. The `publicMethod()` is public, `protectedMethod()` is protected, `defaultMethod()` has default access (package-private), and `privateMethod()` is private.

The `Subclass` extends the `Superclass` and overrides the methods with the appropriate access specifiers. It provides its own implementations for the overridden methods.

In the `Main` class, we create an instance of `Subclass` and invoke the overridden methods. The output will be:

This is the overridden public method.
This is the overridden protected method.
This is the overridden default method (package-private).

Note that attempting to override the `privateMethod()` in the `Subclass` would result in a compilation error because private methods cannot be overridden.

This example demonstrates how different access specifiers can be used in method overriding to control the visibility and accessibility of methods in subclasses. It showcases the behavior of methods with various access modifiers when overridden in a subclass.

Best Practices:

1. Use the `@Override` annotation: Adding `@Override` before the overridden method declaration helps catch errors during compilation and enhances code readability.

2. Document Overrides: Provide appropriate Javadoc or comments to document why and how a method is being overridden, especially when the behavior is different from the superclass implementation.

3. Respect the Liskov Substitution Principle: The overriding method should not weaken the preconditions or strengthen the postconditions defined by the superclass method. It should adhere to the principle of substitutability.

Example of Method Overriding: 

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

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

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

public class Main {
    public static void main(String[] args) {
        Animal animal = new Animal();
        Dog dog = new Dog();
        Cat cat = new Cat();

        animal.makeSound(); // Output: Animal makes a sound.
        dog.makeSound();    // Output: Dog barks.
        cat.makeSound();    // Output: Cat meows.
    }
}

In this example, we have a superclass Animal with a method makeSound() that simply prints "Animal makes a sound." The subclasses Dog and Cat extend the Animal class and override the makeSound() method with their specific implementations. In the Main class, we create instances of Animal, Dog, and Cat. When we call the makeSound() method on each object, the appropriate overridden method is invoked based on the actual type of the object. This demonstrates polymorphism, where the behavior of the overridden method is determined at runtime based on the actual object type. 

The output of the program will be:

Animal makes a sound.
Dog barks.
Cat meows.

This example showcases how method overriding allows subclasses to provide their implementations of inherited methods. Each subclass can override the makeSound() method defined in the Animal superclass to add specific behavior based on the type of animal.

Overriding Abstract Methods:

In Java, abstract classes are created to be the superclass of other classes. And, if a class contains an abstract method, it is mandatory to override it.

We will learn more about abstract classes and overriding of abstract methods in later blog tutorials.

Conclusion:

Java method overriding is a powerful feature that allows subclasses to provide their implementation of methods inherited from superclasses. It enhances code reusability, flexibility, and extensibility, making it an essential tool for achieving polymorphism. By understanding the syntax, rules, and best practices of method overriding, you can write cleaner and more maintainable code. So go ahead, leverage the power of method overriding to design robust and elegant Java applications!