Inheritance

Inheritance is an object-oriented programming concept where a new class, known as a subclass or derived class, inherits the properties and behaviors (attributes and methods) from another class, known as the superclass or base class. Inheritance allows for code reusability and the creation of a hierarchical relationship between classes.

IS-A Relationship

The "IS-A" relationship in inheritance represents a relationship between two classes where one class is a specialized form of another. Example

        
        class Animal {
            void eat() {
                System.out.println("Animal is eating");
            }
        }
    
        class Dog extends Animal {
            void bark() {
                System.out.println("Dog is barking");
            }
        }
    
        public class Main {
            public static void main(String[] args) {
                Dog dog = new Dog();
                dog.eat();  // Inherited from Animal
                dog.bark(); // Specific to Dog
            }
        }
        
    

Types of Inheritance

• Single Inheritance: A subclass inherits from only one superclass.

• Multiple Inheritance: A subclass inherits from more than one superclass (Java doesn't support this directly but can be achieved using interfaces).

• Multi-level Inheritance: A class is derived from a class, which is also derived from another class.

• Hierarchical Inheritance: Multiple classes inherit from the same superclass.

• Hybrid Inheritance: A combination of two or more types of inheritance (achieved in Java through interfaces).

Implementation of All Types of Inheritance in a Single Class

    // Base class (Super class)
    class Animal {
        void eat() {
            System.out.println("Animal is eating");
        }
    }
    
    // Single Inheritance: Dog extends Animal
    class Dog extends Animal {
        void bark() {
            System.out.println("Dog is barking");
        }
    }
    
    // Multi-level Inheritance: Dog extends Animal and Puppy extends Dog
    class Puppy extends Dog {
        void weep() {
            System.out.println("Puppy is weeping");
        }
    }
    
    // Hierarchical Inheritance: Dog and Cat both extends Animal
    class Cat extends Animal {
        void meow() {
            System.out.println("Cat is meowing");
        }
    }
    
    // Multiple Inheritance via Interface
    interface Pet {
        void play();
    }
    
    class DomesticDog extends Dog implements Pet {
        public void play() {
            System.out.println("Dog is playing");
        }
    }
    
    public class Main {
        public static void main(String[] args) {
            // Single Inheritance
            Dog dog = new Dog();
            dog.eat();
            dog.bark();
    
            // Multi-level Inheritance
            Puppy puppy = new Puppy();
            puppy.eat();
            puppy.bark();
            puppy.weep();
    
            // Hierarchical Inheritance
            Cat cat = new Cat();
            cat.eat();
            cat.meow();
    
            // Multiple Inheritance via Interface
            DomesticDog domesticDog = new DomesticDog();
            domesticDog.play();
            domesticDog.bark();
            domesticDog.eat();
        }
    }

Advantages of Inheritance

• Code Reusability: Inheritance allows classes to reuse methods and fields of the superclass without rewriting code.
• Method Overriding: Subclasses can override methods of the superclass to provide specific implementations.
• Extensibility: It allows the creation of a hierarchical structure where classes can be extended with additional functionality.
• Maintenance: Inheritance simplifies maintenance since changes made in the superclass are automatically reflected in subclasses.

Tricky Interview Questions and Answers on Inheritance