Inheritance in Java

Inheritance lets one class acquire the properties and methods of another. It models the IS-A relationship — a Dog is an Animal. Inheritance promotes reuse, hierarchy and polymorphism, and is one of the four pillars of object-oriented programming.

• Syntax: class Child extends Parent { … }
• Access parent: super.method()
• Parent constructor: super(); at first line.
• A class can extend only one class but implement many interfaces.

Let's start with a hands-on example. The program below shows the core idea behind Inheritance in just a few lines of Java. Read it line by line and observe how Java executes each statement in order.

class Animal
{
    void eat() { System.out.println("Eating..."); }
}

class Dog extends Animal
{
    void bark() { System.out.println("Barking..."); }
}

class Main
{
    public static void main(String args[])
    {
        Dog d = new Dog();
        d.eat();
        d.bark();
    }
}

The following examples progress from simple to more practical patterns. Try each in your IDE, change the inputs and observe the output. This is the fastest way to internalize the concept.

class A { void show()  { System.out.println("A"); } }
class B extends A { void show2() { System.out.println("B"); } }
class C extends B { void show3() { System.out.println("C"); } }

class Main
{
    public static void main(String args[])
    {
        C obj = new C();
        obj.show();
        obj.show2();
        obj.show3();
    }
}

class Animal { void eat() { System.out.println("Eat"); } }

class Dog extends Animal { void bark() { System.out.println("Bark"); } }
class Cat extends Animal { void meow() { System.out.println("Meow"); } }

class Main
{
    public static void main(String args[])
    {
        new Dog().eat();
        new Cat().eat();
    }
}

class Vehicle
{
    Vehicle() { System.out.println("Vehicle created"); }
}

class Car extends Vehicle
{
    Car()
    {
        super();
        System.out.println("Car created");
    }
}

class Main
{
    public static void main(String args[])
    {
        new Car();
    }
}

class Bank
{
    int rate() { return 4; }
}

class SBI extends Bank
{
    int rate() { return super.rate() + 2; }
}

class Main
{
    public static void main(String args[])
    {
        System.out.println(new SBI().rate());
    }
}

• Java supports single, multilevel and hierarchical inheritance with classes.
• Use interfaces to achieve multiple inheritance of type.
• final classes cannot be extended (e.g. String).
• private members of the parent are not directly accessible in the child.
• Constructors are not inherited but are invoked via super().

Reading is not enough — practice solidifies knowledge. Try every question below in your own editor before peeking at any solution.

• Q1. Create an Employee class and a Manager subclass with extra fields.
• Q2. Demonstrate multilevel inheritance with three classes.
• Q3. Override a method in the subclass and call the parent version via super.
• Q4. Show that a private parent field is not accessible in the subclass.
• Q5. Build a Shape → Circle / Triangle hierarchy with area().

These are the most common questions asked in Java interviews on this topic. Memorize the concept, not just the answer — interviewers often follow up with edge cases.

Even experienced developers slip on the same pitfalls. Watch out for these classic mistakes while working with Inheritance in Java:

• Forgetting the semicolon ; at the end of statements while using Inheritance.
• Mixing up similar method names — read Java docs before using new APIs related to Inheritance.
• Ignoring compiler warnings — they often hint at bugs that will appear later in production.
• Hard-coding values that should come from configuration files or environment variables.
• Not handling edge cases: empty inputs, very large inputs, negative numbers and null references.
• Skipping unit tests — small tests prevent big regressions, especially around control flow.