Inheritance in Java

This article describes Inheritance in Java.

11/12/20234 min read

Inheritance is a fundamental concept in object-oriented programming (OOP), and Java, being a purely object-oriented language, places a strong emphasis on it Inheritance allows one class to inherit the properties and behaviors of another, fostering code reuse, extensibility, and the creation of well-organized and modular software In this comprehensive exploration, we will delve into the principles of inheritance, the syntax used in Java, and best practices for effective utilization

Principles of Inheritance


At its core, inheritance promotes the reuse of code A class that inherits from another class can leverage its attributes and methods, eliminating the need to rewrite or duplicate code This not only saves development time but also contributes to code maintainability and reduces the chance of errors.


Inheritance facilitates extensibility by allowing the creation of a new class based on an existing one The new class, known as the subclass or derived class, can inherit the attributes and behaviors of the existing class, known as the superclass or base class Developers can then add or override methods, properties, or behaviors to meet specific requirements without modifying the original code


Polymorphism, another crucial OOP concept, is closely tied to inheritance Polymorphism allows objects of different classes to be treated as objects of a common base class This simplifies code and fosters flexibility, as a method defined in a superclass can be implemented differently in each subclass, allowing for a diverse set of behaviors while maintaining a consistent interface

Syntax of Inheritance in Java

extends Keyword

In Java, the extends keyword is used to establish an inheritance relationship between classes Here's a basic example

class Animal {

void eat() {

Systemoutprintln("This animal eats food");}}

class Dog extends Animal {

void bark() {

Systemoutprintln("The dog barks");}}

In this example, the Dog class extends the Animal class As a result, Dog inherits the eat method from Animal, and we can also add new methods like bark specific to the Dog class

super Keyword

The super keyword is used to refer to the immediate parent class object It is often used to invoke the superclass methods, access superclass fields, or invoke the superclass constructor Consider the following example:

class Animal {

void eat() {

System.out.println("This animal eats food");}}

class Dog extends Animal {

void eat() {

supereat(); // invoking the eat method of the superclass

System.out.println("The dog eats bones");}}

Here, the Dog class overrides the eat method from the Animal class but also calls the eat method of the superclass using supereat() before adding its specific behavior

final Keyword

In Java, the final keyword can be used to prevent a class from being inherited or a method from being overridden For example:

final class FinalClass {

// Class implementation


class SubClass /*extends FinalClass*/ {

// Error: Cannot inherit from a final class


class Animal {

final void eat() {

Systemoutprintln("This animal eats food");}}

class Dog extends Animal {

// Error: Cannot override a final method

// void eat() {

// Systemoutprintln("The dog eats bones");

// }


In the above example, FinalClass is marked as final, making it impossible to create subclasses Similarly, the eat method in the Animal class is marked as final, preventing it from being overridden by any subclass

Types of Inheritance

Single Inheritance

Java supports single inheritance, meaning a class can extend only one superclass For example:

class Animal {

// Animal class implementation


class Mammal extends Animal {

// Mammal class implementation


class Dog extends Mammal {

// Dog class implementation


Here, Mammal extends Animal, and Dog extends Mammal, establishing a single inheritance chain

Multiple Inheritance (Interface-based)

While Java does not support multiple inheritance in terms of classes, it does support it through interfaces An interface in Java is a collection of abstract methods, and a class can implement multiple interfaces For example:

interface Swimmer {

void swim();


interface Flyer {

void fly();


class Bird implements Swimmer, Flyer {

public void swim() {

Systemoutprintln("The bird is swimming");


public void fly() {

Systemoutprintln("The bird is flying");



In this example, the Bird class implements both the Swimmer and Flyer interfaces, effectively achieving a form of multiple inheritance

Hierarchical Inheritance

Hierarchical inheritance involves one superclass and multiple subclasses Each subclass inherits from the same superclass For example:

class Shape {

// Shape class implementation


class Circle extends Shape {

// Circle class implementation


class Rectangle extends Shape {

// Rectangle class implementation}

class Triangle extends Shape {

// Triangle class implementation


Here, Circle, Rectangle, and Triangle are subclasses of the Shape superclass, forming a hierarchical inheritance structure

Best Practices for Inheritance in Java

Favor Composition over Inheritance

While inheritance is a powerful tool, it can lead to code that is hard to understand and maintain if not used judiciously The principle of "favor composition over inheritance" suggests that, in some cases, composing objects with existing classes (using composition) can be more flexible and modular than using inheritance This approach allows for greater encapsulation and reduces the coupling between classes

Use Abstract Classes and Interfaces Wisely

Abstract classes and interfaces play a crucial role in inheritance Abstract classes can provide a common base for subclasses, while interfaces define a contract that classes must adhere to Use abstract classes when you want to share code among related classes, and use interfaces to define shared behaviors that can be implemented by unrelated classes

Follow the Liskov Substitution Principle (LSP)

The Liskov Substitution Principle, one of the SOLID principles of object-oriented design, states that objects of a superclass should be replaceable with objects of a subclass without affecting the correctness of the program In Java, this means that a subclass should extend the behavior of its superclass without altering its intended functionality Violating the LSP can lead to unexpected behavior in the program

Use @Override Annotation

When overriding methods in a subclass, it is a good practice to use the @Override annotation This annotation ensures that the method in the subclass is intended to override a method in the superclass It helps catch errors at compile-time if the method signature in the subclass does not match any method in the superclass

class Animal {

void eat()


System.out.println("This animal eats food");}}

class Dog extends Animal {


void eat() {

System.out.println("The dog eats bones");



Keep the Inheritance Hierarchy Simple

Avoid deep and complex inheritance hierarchies, as they can make the code harder to understand and maintain Strive for a simple and logical hierarchy that reflects the relationships between classes If a class needs to inherit from multiple sources of behavior, consider using interfaces or composition to achieve the desired functionality


Inheritance is a foundational concept in Java and object-oriented programming, providing a mechanism for code reuse, extensibility, and polymorphism By understanding the principles of inheritance, mastering the syntax in Java, and adhering to best practices, developers can create well-structured and maintainable code.The flexibility of inheritance in Java allows developers to design elegant and modular systems However, it is essential to use inheritance judiciously and in conjunction with other OOP principles to achieve the desired balance between code reuse and maintainability As Java continues to evolve, the effective use of inheritance remains a cornerstone in the development of robust and scalable software solutions

deadlock in JAVA