2026-03-067 min read

Java Inheritance

Learn Java Inheritance step by step with clear examples and exercises.

Why This Matters

Java inheritance is a vital concept in object-oriented programming that allows for code reusability, reducing redundancy, and organizing complex systems. By understanding inheritance, developers can create more efficient and maintainable codebases. Additionally, familiarity with inheritance is essential for preparing for interviews, real-world projects, and debugging common issues during development.

Prerequisites

Before diving into Java inheritance, you should have a good understanding of the following:

Basics of Java programming (variables, methods, loops, control structures)
Object-oriented programming concepts (classes, objects, encapsulation, and polymorphism)
Access modifiers (public, private, protected, default)
Interfaces in Java
Understanding the differences between classes, objects, and instances
Familiarity with exception handling and streams in Java
Knowledge of Java collections framework (ArrayList, HashMap, LinkedList, etc.)
Basic understanding of Java's file I/O operations
Familiarity with Java's concurrency features (Threads, Synchronization, and Locks)
Understanding the concept of static members in classes

Core Concept

Definition of Inheritance

Inheritance is a mechanism that allows one class to inherit properties (attributes and methods) from another class called the parent or superclass. The inheriting class is known as the subclass or child class.

public class Parent {
// attributes and methods of the parent class
}

public class Child extends Parent {
// additional attributes and methods specific to the child class
}

In this example, Child is a subclass that inherits from the Parent class. The extends keyword indicates inheritance.

Accessing Inherited Members

When a member (attribute or method) is inherited, it can be accessed using its original name within the child class. However, if there's a conflict between the member names in both classes, the child class member takes precedence.

public class Parent {
int x = 10; // attribute of parent class
}

public class Child extends Parent {
int x = 20; // attribute of child class (overrides parent's x)

void showX() {
System.out.println(x); // prints the value of child class's x (20)
}
}

Method Overriding

Method overriding is a feature that allows a subclass to provide its own implementation for an inherited method from the superclass. To override a method, the subclass must declare a method with the same signature (name, return type, and parameters) as the superclass method.

public class Parent {
void showMessage() {
System.out.println("Hello from Parent!");
}
}

public class Child extends Parent {
void showMessage() { // overrides parent's showMessage()
System.out.println("Hello from Child!");
}
}

Overriding Final Methods and Accessing Private Members

Final methods cannot be overridden in a subclass. However, private members are not accessible outside their class, including subclasses. To access private members within the same package, use the this keyword or make them protected and access them through an instance of the superclass.

public class Parent {
private int x = 10; // private attribute of parent class

final void showX() { // final method of parent class
System.out.println(x);
}
}

public class Child extends Parent {
void accessPrivateX() {
this.showX(); // calls the parent's showX() method
}
}

Static Members and Inheritance

Static members are shared among all instances of a class, not just within an inheritance hierarchy. However, if a subclass declares a static member with the same name as a static member in its superclass, it hides the superclass's static member. To access the hidden static member, use the super keyword.

public class Parent {
static int x = 10; // static attribute of parent class
}

public class Child extends Parent {
static int x = 20; // static attribute of child class (hides parent's x)

void showX() {
System.out.println(Parent.x); // prints the value of parent's x (10) using super.x
}
}

Worked Example

Let's create a simple example of inheritance with method overriding and static members:

public class Animal {
static int count = 0; // static attribute of Animal class
String name;

public Animal(String name) {
this.name = name;
count++;
}

void introduce() {
System.out.println("I am an animal named " + name);
}

static void showCount() {
System.out.println("Total animals created: " + count);
}
}

public class Cat extends Animal {
int age;

public Cat(String name, int age) {
super(name); // calls the parent constructor
this.age = age;
}

void introduce() { // overrides parent's introduce()
System.out.println("I am a cat named " + name + ". I am " + age + " years old.");
}

void showCount() { // hides parent's showCount()
super.showCount(); // calls the parent's showCount() method
}
}

In this example, Cat is a subclass of Animal. The Cat class inherits the name attribute and both versions of the introduce() method from the Animal class. However, it also has its own age attribute and provides an implementation for the introduce() method that suits cats specifically. Additionally, the example demonstrates static members in inheritance hierarchies.

Common Mistakes

Forgetting to call the superclass constructor: When creating a subclass constructor, remember to call the parent constructor using the super() keyword.
Incorrect method overriding: Ensure that the method signature in the subclass matches the one in the superclass exactly (including return type).
Accessing private members from the subclass: Private members are not accessible outside their class, including subclasses. However, they can be accessed within the same package using the this keyword or by making them protected and accessing them through an instance of the superclass.
Overriding final methods: Final methods cannot be overridden in a subclass.
Incorrect use of the this keyword: Using this within a constructor can lead to confusion and errors if not used correctly, such as creating infinite loops or calling non-existent constructors.
Inheriting private members: Private members are not accessible outside their class, including subclasses.
Creating circular inheritance: Avoid creating circular inheritance relationships between classes, where one class extends another and that other class extends the first class.
Misusing final keyword: Using the final keyword inappropriately can lead to issues, such as preventing a class from being extended or a method from being overridden when it should be.
Incorrectly implementing abstract methods: When a class is declared as abstract, it must contain at least one abstract method. If a concrete subclass does not implement all the abstract methods of its superclass, it should also be declared as abstract.
Forgetting to override toString() method: Overriding the toString() method can help provide more meaningful output when an object is converted to a string, making debugging easier.

Practice Questions

Create a class hierarchy where Vehicle is the superclass, and Car, Bike, and Truck are subclasses. Override the move() method in each subclass to provide specific movement behaviors.

Vehicle: A generic vehicle with a move() method that prints "Moving..."
Car: A car that moves by driving and overrides the move() method to print "Driving..."
Bike: A bike that moves by pedaling and overrides the move() method to print "Pedaling..."
Truck: A truck that moves by hauling and overrides the move() method to print "Hauling..."

Write a program that demonstrates method overriding with multiple levels of inheritance (e.g., Animal, Mammal, Cat, and Lion).

Animal: A superclass with an eat() method that prints "Eating..."
Mammal: A subclass of Animal that overrides the eat() method to print "Chewing food..."
Cat: A subclass of Mammal that overrides the eat() method to print "Licking food..."
Lion: A subclass of Mammal that does not override the eat() method, so it calls the parent's implementation.

FAQ

Can a class inherit from more than one superclass?: No, Java does not support multiple inheritance directly. However, interfaces can be used to achieve similar functionality.
What is the difference between an abstract class and an interface?: An abstract class can have implemented methods, while an interface only contains method signatures without implementations. Abstract classes can also have instance variables, whereas interfaces cannot.
Can a subclass access private members of its superclass?: No, private members are not accessible outside their class, including subclasses. However, they can be accessed within the same package using the this keyword or by making them protected and accessing them through an instance of the superclass.
Can a final method be overridden in a subclass?: No, final methods cannot be overridden in a subclass because their implementation is fixed at compile time.
What happens when a subclass does not implement all the abstract methods of its superclass?: If a concrete subclass does not implement all the abstract methods of its superclass, it should also be declared as abstract and cannot be instantiated on its own.
Can a class extend another class and implement an interface at the same time?: Yes, a class can extend one superclass and implement multiple interfaces in Java.
What is the purpose of the final keyword in Java?: The final keyword can be used to declare constants, make methods unoverrideable, or restrict subclasses from being extended.
Can a method in an interface have a body?: No, methods in interfaces cannot have bodies; they only contain method signatures without implementations.
What is the purpose of the static keyword in Java?: The static keyword can be used to declare static members (variables and methods) that belong to the class as a whole, rather than to individual instances of the class.
Can a subclass access the private members of its superclass through an instance of the superclass?: Yes, a subclass can access private members of its superclass through an instance of the superclass using the this keyword or by making them protected and accessing them directly.