Inheritance is a fundamental concept in object-oriented programming that allows one class to inherit properties and behaviors from another class. In our previous article, we discussed classes in Java, which are a blueprint for creating objects with specific properties and behaviors. Now, we will dive deeper into the concept of inheritance and how it allows for the reuse and extension of code.

Before we explore inheritance in depth, it’s important to have a solid understanding of classes and how they work in Java. If you are new to classes, or need some practice problems to hone your skills, we recommend reading our “Practice Questions  on Class and Objects” article.

In this article, we will cover the basics of inheritance in Java, including the benefits and drawbacks of inheritance, and how inheritance supports polymorphism. We will also provide some examples of how inheritance can be used in practice, how it differs from composition, and some best practices for using inheritance effectively in your Java code.

So let’s get started!

What is Inheritance?

• Inheritance is a concept in object-oriented programming that allows one class to inherit properties and behaviors from another class. Think of it like a family tree, where a child inherits certain traits and characteristics from their parent. Similarly, in programming, a child class can inherit properties and behaviors from its parent class. This can save time and effort by reusing existing code and can also help make programs easier to understand and maintain.
• The class that is being inherited from is called the Super class or Parent class or Base class, while the class that inherits from it is called the subclass or child class or derived class.
• The subclass can reuse the code and functionality of the superclass, as well as add new methods or override existing ones.
• To define a subclass in Java, the extends keyword is used followed by the name of the superclass.
• Example :

class Study{
   public void everytime() {
      System.out.println("Impossible to Study Everytime");
   }
}

class Trigger extends Study{
   public void motivate() {
      System.out.println("Pls motivate me to Study hard!");
   }
}

public class InheritanceExp{
   public static void main(String[] args) {
      Trigger Ob = new Trigger();
      Ob.everytime(); // call everytime() method from Study class i.e from parent class
      Ob.motivate(); // call motivate method from Trigger class
   }
}

In this example, the Trigger class is a subclass of Study and inherits the everytime() method from it. It also has its own unique motivate() method.

“Save the above code as “InheritanceExp”. After saving it, compile and run the code. You will get the below output.

Impossible to Study Everytime
Pls motivate me to Study hard!

Inheritance promotes code reusability and makes the code more organized and easier to maintain. However, it should be used carefully to avoid creating overly complex class hierarchies and tightly coupled code.

I hope that you can now clearly understand what inheritance is and how to implement it. Let’s take a look at some of the benefits and drawbacks of using inheritance.

Advantages of Inheritance

1. Code reusability: With inheritance, a subclass can inherit methods and properties from its parent class, allowing developers to reuse code without having to rewrite it.

2. Improved code organization: Inheritance can help to organize code by grouping related classes together in a hierarchical structure.

3. Polymorphism: In Java, inheritance enables the use of polymorphism, which allows objects to take on multiple forms. This means that a variable of a parent class type can hold objects of any of its subclasses.

4. Modularity: Inheritance promotes modularity by separating the implementation details of a class from its interface. This allows developers to modify and extend the behavior of a class without affecting the code that uses it.

5. Flexibility and extensibility: Inheritance provides a flexible and extensible way to define new classes by inheriting and modifying existing classes. This allows developers to create new classes that are similar to existing ones, but with additional functionality or customization.

Overall, inheritance is a powerful mechanism in Java that can help to reduce code duplication, improve code organization, promote modularity, and enhance the flexibility and extensibility of software systems.

Disadvantages of Inheritance

Although inheritance provides several benefits in Java, there are also some disadvantages that should be considered when using this mechanism:

1. Tight coupling: Inheritance can result in tight coupling between classes, making the code more complex and difficult to maintain. Changes to the superclass can affect the behavior of all its subclasses, which can lead to unexpected consequences and make it harder to modify or extend the code.

2. Fragile base class problem: The fragile base class problem occurs when changes to the superclass can break the functionality of the subclass. This can be a problem when the superclass is widely used or has many subclasses, as it can require extensive testing and refactoring to ensure that changes to the superclass do not have unintended consequences for its subclasses.

3. Inflexibility: Inheritance can be inflexible when compared to other mechanisms such as composition, which allows for greater flexibility and modularity. Subclasses are limited to the functionality and behavior of their parent class, and changes to the parent class can have a cascading effect on all its subclasses.

4. Overuse: Inheritance can be overused, resulting in overly complex class hierarchies and code that is difficult to understand and maintain. In some cases, composition or other mechanisms may be more appropriate for achieving the desired functionality.

Have you heard about Composition? After reading about inheritance, you may be confused about how inheritance different from composition (containership).

What is Composition?

Composition refers to the practice of combining multiple classes to create more complex objects. In other words, a class can contain an instance of another class as one of its member variables.

For example, consider a car class. The car class can contain instances of other classes such as an engine class, a transmission class, and a steering class, which define the properties and behaviors of those components. By combining these classes through composition, you can create a more complex object that represents a complete car.

Here’s an example of how composition works in Java:

public class Engine {
   // Properties and behaviors of the engine
}

public class Wheel {
   // Properties and behaviors of a wheel
}

public class SteeringWheel {
   // Properties and behaviors of a steering wheel
}

public class Car {
   private Engine engine;
   private Wheel[] wheels;
   private SteeringWheel steeringWheel;
   
   public Car(Engine engine, Wheel[] wheels, SteeringWheel steeringWheel) {
      this.engine = engine;
      this.wheels = wheels;
      this.steeringWheel = steeringWheel;
   }
   
   // Methods and behaviors of the car
}