Inheritance

A courier company runs bikes, vans and refrigerated trucks. Every one of them has a registration number, a driver and a fuel level, and every one can start a trip and log a delivery. If you write a separate class for each vehicle, you type those same fields and methods three times. Then a bug appears in the trip logic, and you have to fix it in three places and hope you did not miss one.

Inheritance solves this. You write the shared part once in a parent class, and each vehicle class takes it over and adds only what makes it different. Below you will see how extends works, what a child class does and does not receive, the order in which constructors run up the chain, and why Java lets a class have only one parent.

What is Inheritance?

The class that gives is called the parent, superclass or base class. The class that receives is called the child, subclass or derived class. A child can use everything it inherits as if it had written it, add new fields and methods, and replace inherited methods with its own versions, which is called overriding.

A quick test tells you whether inheritance fits: say the sentence "a child is a parent" out loud. "A van is a vehicle" sounds right. "A van is an engine" does not, so a van should have an engine field instead of extending an engine class. That HAS-A link is called composition.

Why is Inheritance used?

• Code reuse. Shared fields and methods live in one class, so you write and test them once.
• Easy extension. A new vehicle type needs only its extra details; the common behaviour is already there.
• One place to fix. A correction in the parent reaches every child automatically.
• Clear modelling. The class tree mirrors real categories, which makes large code bases easier to read.
• A base for polymorphism. Because a van IS-A vehicle, a Vehicle variable can hold a van, and one loop can handle every kind of vehicle.

Real-Life Example

Think of a restaurant franchise. Head office writes the standard menu, the kitchen rules and the billing system. When a new outlet opens, it gets all of that on day one, without redesigning anything. The outlet may add a few local dishes, and it may change how one standard dish is served in its city. Some things stay locked at head office, such as the secret spice recipe; the outlet benefits from the result but never sees the recipe itself.

Map it back to Java. Head office is the superclass. Each outlet is a subclass created with extends. The standard menu is the inherited methods, local dishes are new methods, and the changed dish is an overridden method. The secret recipe is a private member: it exists inside every object, but the child class cannot touch it directly.

java
class Parent {
    protected String shared;

    void commonAction() {
        // used by every child
    }
}

class Child extends Parent {
    int extraField;

    void newAction() {
        // only in Child
    }

    @Override
    void commonAction() {
        super.commonAction();   // optional: reuse parent code
        // then add Child's own steps
    }
}

How Inheritance Works

When you create a child object, Java builds it from the top of the family tree downwards. Every constructor first calls its parent's constructor, either with your own super(...) or with a hidden super() the compiler inserts.

text
new ColdChainTruck()
        |
        v
ColdChainTruck() called
 -> super() first
        |
        v
DeliveryVan() called
 -> super() first
        |
        v
Carrier() called
 -> super() first
        |
        v
Object() runs and returns
        |
        v
Carrier body finishes
        |
        v
DeliveryVan body finishes
        |
        v
ColdChainTruck body finishes

The calls travel up the chain until they reach Object, the root of every Java class. Then the bodies finish in the reverse direction, from the top parent down to the class you named in new. This way a child constructor can safely use inherited fields, because the parent has already set them. Only one object is created in the end, and it holds the fields of all three levels together in one block of heap memory.

java
class Vehicle {
    String regNo;
    int fuel = 100;

    void startTrip(String area) {
        fuel -= 10;
        System.out.println(regNo + " heading to " + area);
    }
}

class DeliveryBike extends Vehicle {
    int boxLitres;

    void showBox() {
        System.out.println("Box size: " + boxLitres + " L");
    }
}

public class FleetStart {
    public static void main(String[] args) {
        DeliveryBike bike = new DeliveryBike();
        bike.regNo = "KA01-7741";
        bike.boxLitres = 40;
        bike.startTrip("Indiranagar");
        bike.showBox();
        System.out.println("Fuel left: " + bike.fuel);
    }
}

text
KA01-7741 heading to Indiranagar
Box size: 40 L
Fuel left: 90

java
class Carrier {
    Carrier() {
        System.out.println("1. Carrier ready");
    }
}

class DeliveryVan extends Carrier {
    DeliveryVan() {
        System.out.println("2. Van body fitted");
    }
}

class ColdChainTruck extends DeliveryVan {
    int tempC;

    ColdChainTruck(int tempC) {
        super();
        this.tempC = tempC;
        System.out.println("3. Cooling set to " + tempC + " C");
    }
}

public class BuildOrder {
    public static void main(String[] args) {
        new ColdChainTruck(4);
    }
}

text
1. Carrier ready
2. Van body fitted
3. Cooling set to 4 C

java
class Courier {
    private int deliveries;

    void logDelivery() {
        deliveries++;
    }

    int getDeliveries() {
        return deliveries;
    }

    String status() {
        return "Deliveries: " + deliveries;
    }
}

class DroneCourier extends Courier {
    int batteryPct = 90;

    @Override
    String status() {
        return super.status() + ", battery " + batteryPct + "%";
    }
}

public class DroneReport {
    public static void main(String[] args) {
        DroneCourier drone = new DroneCourier();
        drone.logDelivery();
        drone.logDelivery();
        System.out.println(drone.status());
        System.out.println("Count via getter: " + drone.getDeliveries());
        System.out.println(drone instanceof Courier);
    }
}

text
Deliveries: 2, battery 90%
Count via getter: 2
true

Why Java Allows Only One Parent Class

Imagine two parent classes that both define charge() with different code, and a third class that extends both.

text
        Charger
        /     \
  FastCharger  SolarCharger
        \     /
      HybridCharger

If HybridCharger calls charge(), which version should run? This is the diamond problem. It also raises harder questions, such as which parent constructor runs first and whether the shared grandparent's fields exist once or twice. Java's designers avoided all of it by allowing only one superclass per class. When you need a class to play several roles, you implement several interfaces instead, and if two interfaces clash on a default method, the compiler forces the class to choose.

Common Mistakes

• Expecting private fields to be directly visible. A child cannot write parent.privateField. Use protected members or getters.
• Forgetting that the parent needs a constructor to call. If the parent has only Vehicle(String reg), every child constructor must call super(reg) itself, or the code fails to compile.
• Missing `@Override`. Without it, a small typo in the method name creates a brand new method, and the parent's version keeps running.
• Trying to extend two classes. class A extends B, C is a compile error in Java.
• Extending a `final` class. Classes such as String are final and cannot have subclasses.

Interview Questions

Summary

• Inheritance lets a subclass reuse and extend a superclass with extends.
• It models an IS-A relationship; use composition for HAS-A links.
• Public, protected and same-package members are inherited; private members and constructors are not directly usable.
• Constructors run from the top parent down, because each one calls super() first.
• A class can extend only one class, which avoids the diamond problem.
• @Override and super.method() let you change or extend inherited behaviour safely.

Related Topics

• Types of Inheritance: single, multilevel and hierarchical trees.
• super Keyword: reaching parent constructors and methods.
• Method Overriding: replacing inherited behaviour correctly.
• Polymorphism: using one parent type for many children.