Java Inheritance Basics: Understand Inheritance in Java with Examples

Imagine you are building an application for a company. You create a Vehicle class with common features such as speed, color, and starting the engine. Later, you need Car, Bike, and Truck classes. Writing the same fields and methods again in every class would work, but it would create unnecessary duplication.

Java provides inheritance to solve this problem. Inheritance allows one class to acquire accessible fields and methods from another class and then add its own specialized behavior.

Inheritance is an object-oriented programming mechanism in which a child class derives from a parent class and reuses its accessible members.

Why Does Inheritance Exist?

The main purpose of inheritance is to represent an is-a relationship and promote code reuse. If a Car is a type of Vehicle, then common behavior can live inside Vehicle, while Car can focus on its specialized behavior.

class Vehicle {
    void start() {
        System.out.println("Vehicle is starting");
    }
}

class Car extends Vehicle {
    void drive() {
        System.out.println("Car is driving");
    }
}

Here, Vehicle is the parent class and Car is the child class. The Car class can use the inherited start() method while also providing its own drive() method.

A Simple Real-World Analogy

Think about an organization. A general employee may have common information such as a name and employee ID. A developer is an employee, but a developer also has specialized responsibilities such as writing software. Instead of treating every type of employee as completely unrelated, we can model their common characteristics in a parent class and their specialized characteristics in child classes.

Parent class → common characteristics and behavior

Child class → inherited characteristics plus specialized behavior

Basic Inheritance Example

class Animal {
    String name = "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();

        System.out.println(dog.name);
        dog.eat();
        dog.bark();
    }
}

The Dog object can access name and eat() because they are inherited from Animal. It can also call its own bark() method.

What Is Actually Being Reused?

Inheritance does not mean that the child class receives a completely separate copy of the parent class's implementation. The parent portion of the object exists as part of the child object, and Java's inheritance rules determine which members are accessible through the child.

For example, if Dog extends Animal, a Dog object represents both the Animal part and the specialized Dog part.

Dog dog = new Dog();

This creates a Dog object, but that object also contains the inherited state associated with Animal.

Inheritance and Access Modifiers

A common beginner mistake is assuming that every parent member automatically becomes directly accessible inside the child class. That is not true. Access depends on the member's access modifier.

Modifier	Accessible in Child Class	Key Point
public	Yes	Accessible wherever the normal public access rules allow.
protected	Yes	Designed to support access from subclasses.
default	Conditionally	Directly accessible when the child is in the same package.
private	No direct access	Accessible only inside the class that declares it.

Inheritance Is More Than Code Reuse

Code reuse is useful, but experienced developers do not use inheritance merely because two classes share a few methods. The more important question is whether the child truly represents a specialized form of the parent.

For example, Car extends Vehicle makes conceptual sense because a car is a vehicle. But Engine extends Vehicle would be a poor model because an engine is not a vehicle; it is a component of a vehicle.

Practical rule: Use inheritance when the relationship naturally reads as "A child is a type of parent." If the relationship is better described as "A class has another object," composition is often the better design.

Common Beginner Mistakes

• Using inheritance simply to avoid writing duplicate code.
• Assuming private members can be accessed directly from a child class.
• Creating inheritance relationships that do not represent a genuine is-a relationship.
• Thinking inheritance automatically means every parent member is freely accessible.
• Creating very deep inheritance hierarchies when a simpler design would be easier to maintain.

Inheritance: Quick Revision

Concept	Meaning
Inheritance	A mechanism for deriving one class from another.
Parent class	The class whose accessible members can be inherited.
Child class	The class that derives from the parent class.
is-a relationship	The conceptual relationship represented by inheritance.
Code reuse	One important advantage of inheritance, but not its only purpose.
Access control	Determines which inherited members can be accessed directly.

Interview Insight

In an interview, do not define inheritance only as "reusing code." A stronger answer is: Inheritance is an object-oriented mechanism in Java where a child class derives from a parent class, allowing it to reuse accessible behavior and state while specializing or extending that behavior. It is primarily appropriate for a genuine is-a relationship.

Final Takeaway

Inheritance gives Java developers a structured way to model relationships between related classes. A well-designed child class does not merely copy functionality from its parent; it represents a meaningful specialization. Once you understand this idea, the upcoming concepts such as extends, method overriding, super, and different inheritance structures become much easier to understand.