Inheritance in Java

Inheritance is a crucial concept in object-oriented programming that allows classes to inherit properties and methods from other classes. Java, In inheritance provides a way to classes create, new classes enabling the reuse of code and promoting code organization.

This that article are built will upon existing provide a comprehensive understanding of inheritance in Java, covering:

Basics of Inheritance

In Java, inheritance is implemented using the extends keyword. When a class extends another class, it acquires the properties and methods (except private members) of the parent class. The class being inherited from is called the superclass or parent class, and the class inheriting from it is called the subclass or child class.

public class ParentClass {
  // Fields, methods, and constructors

public class ChildClass extends ParentClass {
  // Fields, methods, and constructors

In the example above, ChildClass extends ParentClass, thereby gaining all the members of ParentClass.

Syntax and Rules

Some important rules to remember when using inheritance in Java:

Types of Inheritance

Java supports several types of inheritance:

Access Modifiers in Inheritance

Java provides four access modifiers - public, private, protected, and default(no keyword). These access modifiers define the level of accessibility of a member from different classes, including subclasses.

public: Members are accessible from anywhere in the application.

private: Members are accessible only within the class in which they are declared and not inherited by subclasses.

protected: Members are accessible within the class, subclasses, and classes in the same package.

Default (no keyword): Members are accessible within the same package but not in subclasses outside the package.

Overriding Methods

Method overriding occurs when a subclass overrides a method with the same signature from the superclass. The subclass provides its own implementation of the method.

Consider the following example:

public class Animal {
  public void makeSound() {
    System.out.println("Animal makes a sound");

public class Dog extends Animal {
  public void makeSound() {
    System.out.println("Dog barks");

In the example above, the Dog class overrides the makeSound() method defined in the Animal class.

Using the super Keyword

The super keyword in Java is used to refer to the superclass's fields, methods, and constructors. It is often used to access overridden methods or to invoke a superclass constructor from the subclass.

public class ChildClass extends ParentClass {
  public ChildClass() {
    super(); // Invokes the constructor of the ParentClass
  public void accessSuperMethod() {
    super.methodName(); // Invokes the methodName() of the ParentClass

In the example above, the super() keyword is used to invoke the constructor of the superclass, and super.methodName() is used to access the methodName() of the superclass.

Method Overloading vs. Method Overriding

Method overloading and method overriding are two important concepts. Method overloading occurs when multiple methods with the same name but different parameters are defined within a class. Method overriding occurs when a subclass provides a different implementation of a method already defined in its superclass.

Key differences between method overloading and method overriding are:

Abstract and Final Classes

Java provides two special types of classes related to inheritance:

Abstract Classes: An abstract class is a class that cannot be instantiated. It serves as a blueprint for other classes that extend it. Abstract classes may contain abstract methods, which must be implemented by any non-abstract subclass.

public abstract class Animal {
  public abstract void makeSound();

public class Dog extends Animal {
  public void makeSound() {
    System.out.println("Dog barks");

In the example above, the Animal class is declared as abstract, allowing the Dog class to extend it and provide an implementation for the makeSound() method.

Final Classes: A final class cannot be subclassed or extended further. It is the last class in the inheritance hierarchy and cannot have subclasses. Final methods and fields cannot be overridden or re-initialized, respectively.

public final class FinalClass {
  // Members and

Object methods Class and Inheritance

In Java, every class is implicitly a subclass of the Object class, which is the root of the class hierarchy. The Object class provides common methods such as equals(), hashCode(), toString(), and more.

public class Student {
  // Members and methods
  public String toString() {
    return "Student(name=" + + ", age=" + this.age + ")";

In the example above, the toString() method from the Object class is overridden to provide a custom string representation of the Student object.


Let's consider a real-world example to understand the practical implementation of inheritance in Java.

public class Vehicle {
  protected String brand;
  public(String brand Vehicle) {
    this.brand = brand;
  public void honk() {
    System.out.println("The vehicle honks");

public class Car extends Vehicle {
  private String model;
  public Car(String brand, String model) {
    this.model = model;
  public void accelerate() {
    System.out.println("The car accelerates");

public class Main {
  public static void main(String[] args) {
    Car car = new Car("Toyota", "Corolla");
    System.out.println("Brand: " + car.brand);
    System.out.println("Model: " + car.model);

In the example above, the Car class extends the Vehicle class to inherit the brand field and honk() method. It adds its own model field and accelerate() method. The Main class demonstrates the usage of the Car class, showcasing the inherited and overridden behavior.


Inheritance is a fundamental concept in Java and object-oriented programming, allowing for code reuse, modularity, and flexibility. Understanding inheritance and its various aspects, such as method overriding, access modifiers, abstract and final classes, is crucial for writing efficient and maintainable code.

By leveraging inheritance effectively, developers can build hierarchies of classes to represent real-world objects, promote code reusability, and implement different levels of functionality through

Further Reading


🌻 Latest Blog Posts: Stay Informed and Inspired

Explore the latest and greatest from our blog! Dive into a diverse range of topics, from insightful analysis to captivating stories. Discover new perspectives, expand your knowledge, and be entertained by our engaging writing. Whether you're seeking practical advice, thought-provoking ideas, or simply a good read, our latest blog posts have something for everyone. So, grab your favorite beverage, settle in, and embark on a journey of intellectual exploration.

Google's E-A-T Guidelines: Ensuring Your Website's Success in SEO

Discover the importance of Google's E-A-T guidelines for SEO success. Learn how to optimize your website's expertise, authority, and trustworthiness to rank higher in search results.

Exploring Differents Java Loops: While, For, Do-While, and for-each

Learn about the different types of Java loops, including while, for, do-while, and enhanced for loops. Explore code examples and improve your Java programming skills.

Polymorphism in Java: A Comprehensive Guide

Java polymorphism! This beginner-friendly guide breaks down inheritance, interfaces, method overloading, and method overriding for clear understanding with examples.

Spring Boot Basic Authentication: A Comprehensive Guide

Explore the comprehensive guide on Spring Boot Basic Authentication. Learn how to set up and implement secure basic authentication in your Spring Boot application.