Inheritance and Method Overriding in Java

In Java, inheritance is a mechanism where one class acquires the properties (fields) and behaviors (methods) of another class. Inheritance helps to promote reusability and establish relationships between classes. Method overriding is a feature that allows a subclass to provide a specific implementation of a method that is already defined in its superclass.

1. Inheritance in Java

Inheritance in Java is achieved using the extends keyword. A class that is inherited from is called a superclass, and the class that inherits is called a subclass.

Example 1: Basic Inheritance

In this example, the class Animal is the superclass, and the class Dog is the subclass that inherits from Animal.

    class Animal {
        void eat() {
            System.out.println("This animal eats food.");
        }
    }
    
    class Dog extends Animal {
        void bark() {
            System.out.println("The dog barks.");
        }
    }
    
    public class Main {
        public static void main(String[] args) {
            Dog dog = new Dog();
            dog.eat();  // Inherited method
            dog.bark(); // Method of Dog class
        }
    }

Output:

    This animal eats food.
    The dog barks.

In this example, the Dog class inherits the eat() method from the Animal class.

2. Method Overriding in Java

Method overriding in Java occurs when a subclass defines a method that has the same signature (name, return type, and parameters) as a method in the superclass. The overriding method in the subclass provides a specific implementation of the method.

Method overriding is done using the same method signature, and it must be defined inside the subclass.

Example 2: Method Overriding

In this example, we override the eat() method in the Dog class to provide a more specific implementation:

    class Animal {
        void eat() {
            System.out.println("This animal eats food.");
        }
    }
    
    class Dog extends Animal {
        @Override
        void eat() {
            System.out.println("The dog eats bones.");
        }
    
        void bark() {
            System.out.println("The dog barks.");
        }
    }
    
    public class Main {
        public static void main(String[] args) {
            Animal animal = new Animal();
            animal.eat();  // Calls the Animal class eat() method
    
            Dog dog = new Dog();
            dog.eat();  // Calls the overridden Dog class eat() method
            dog.bark(); // Method of Dog class
        }
    }

Output:

    This animal eats food.
    The dog eats bones.
    The dog barks.

In this example, the Dog class overrides the eat() method of the Animal class, and provides its own implementation for how a dog eats.

3. Why Use Method Overriding?

Method overriding allows a subclass to implement a method that is specific to its behavior, even though it has the same name and signature as a method in the superclass. This makes it easier to use polymorphism, where a superclass reference can refer to a subclass object, and the correct method is called based on the actual object type.

Example 3: Polymorphism with Method Overriding

In this example, we demonstrate how method overriding enables polymorphism:

    class Animal {
        void sound() {
            System.out.println("Animals make sounds.");
        }
    }
    
    class Dog extends Animal {
        @Override
        void sound() {
            System.out.println("The dog barks.");
        }
    }
    
    class Cat extends Animal {
        @Override
        void sound() {
            System.out.println("The cat meows.");
        }
    }
    
    public class Main {
        public static void main(String[] args) {
            Animal animal1 = new Dog();
            animal1.sound();  // Calls Dog's sound() method
    
            Animal animal2 = new Cat();
            animal2.sound();  // Calls Cat's sound() method
        }
    }

Output:

    The dog barks.
    The cat meows.

Here, both Dog and Cat override the sound() method from the superclass Animal. The method called depends on the type of object (Dog or Cat) even though the reference is of type Animal.

4. Using super Keyword to Call Superclass Methods

If you want to call a method from the superclass inside an overridden method in the subclass, you can use the super keyword. This is useful when you want to extend the behavior of the superclass method and add more functionality in the subclass.

Example 4: Using super to Call a Superclass Method

In this example, we call the eat() method from the superclass Animal inside the overridden method of the subclass Dog:

    class Animal {
        void eat() {
            System.out.println("This animal eats food.");
        }
    }
    
    class Dog extends Animal {
        @Override
        void eat() {
            super.eat();  // Call the superclass method
            System.out.println("The dog eats bones.");
        }
    }
    
    public class Main {
        public static void main(String[] args) {
            Dog dog = new Dog();
            dog.eat();  // Calls the Dog class eat() method, which calls the Animal class eat() method
        }
    }

Output:

    This animal eats food.
    The dog eats bones.

In this case, we use super.eat() to call the eat() method of the superclass before adding the subclass-specific behavior.

5. Conclusion

Inheritance and method overriding are key concepts in object-oriented programming (OOP) that help in creating flexible and reusable code. Inheritance allows a subclass to inherit properties and methods from a superclass, while method overriding allows a subclass to provide a specific implementation for a method that is already defined in the superclass. Together, these concepts enable the use of polymorphism, which is crucial for writing more maintainable and extensible Java code.




Advertisement