Exploring Hierarchical Inheritance in Java

Exploring Hierarchical Inheritance in Java

6 mins readComment
Esha
Esha Gupta
Associate Senior Executive
Updated on May 2, 2024 18:12 IST

Have you ever wondered how different elements in a Java program can share common traits while having their unique features? Hierarchical inheritance in Java allows exactly this, letting multiple subclasses inherit from a single superclass, enabling both shared functionalities and individual characteristics to coexist harmoniously in a structured and efficient way. Let's understand more!

Hierarchical inheritance in Java refers to a scenario where one base (or parent) class is inherited by multiple derived (or child) classes. This type of inheritance creates a hierarchy where the common properties and methods of the base class can be shared and used by all its child classes, but each child class can also have its own unique properties and methods.

Types of Inheritance in Java
Types of Inheritance in Java
Inheritance in Java is a fundamental Object-Oriented Programming (OOP) concept that allows one class to inherit fields and methods from another class. Inheritance enables code reuse and establishes a parent-child...read more

This structure promotes code reuse and abstraction, allowing for a more organized and maintainable codebase where common functionality is centralized in the parent class, reducing duplication and encouraging a cleaner design.

Class A is the base/parent class, and Class B, C, and D are the derived/child classes.

Consider a Shape class that includes basic properties like color and methods to calculate area and perimeter. This Shape class can be the base class for multiple derived classes such as Circle, Square, and Triangle. Each of these child classes inherits the properties and methods of Shape but also includes its unique attributes and methods, like radius for Circle, side length for Square, and base and height for Triangle, along with their own implementations of area and perimeter calculations.

 

 

Let's Understand it with One More Real-Life Example with Code Below.
 

Imagine a real estate application that manages different types of properties: residential and commercial. Both property types share some common attributes, such as address and square footage, but each also has unique features. Residential properties have details like the number of bedrooms and bathrooms, while commercial properties include information on lease type and business type.

We will use hierarchical inheritance in Java to model this scenario, showcasing how both property types can inherit common attributes from a generic Property class while also maintaining their unique characteristics.

 


 
// The base class for all properties
class Property {
String address;
double squareFeet;
// Constructor
Property(String address, double squareFeet) {
this.address = address;
this.squareFeet = squareFeet;
}
// Method to display basic property information
void display() {
System.out.println("Address: " + address);
System.out.println("Square Feet: " + squareFeet);
}
}
// Derived class for Residential properties
class Residential extends Property {
int bedrooms;
int bathrooms;
// Constructor
Residential(String address, double squareFeet, int bedrooms, int bathrooms) {
super(address, squareFeet); // Call to base class constructor
this.bedrooms = bedrooms;
this.bathrooms = bathrooms;
}
// Overriding display method to include bedrooms and bathrooms
void display() {
super.display(); // Call base class method
System.out.println("Bedrooms: " + bedrooms);
System.out.println("Bathrooms: " + bathrooms);
}
}
// Derived class for Commercial properties
class Commercial extends Property {
String leaseType;
String businessType;
// Constructor
Commercial(String address, double squareFeet, String leaseType, String businessType) {
super(address, squareFeet); // Call to base class constructor
this.leaseType = leaseType;
this.businessType = businessType;
}
// Overriding display method to include leaseType and businessType
void display() {
super.display(); // Call base class method
System.out.println("Lease Type: " + leaseType);
System.out.println("Business Type: " + businessType);
}
}
// Main class to run the program
class RealEstateManager {
public static void main(String[] args) {
Residential residentialProperty = new Residential("123 Maple St", 1500.0, 3, 2);
Commercial commercialProperty = new Commercial("456 Oak St", 3000.0, "Triple Net", "Retail");
System.out.println("Residential Property Details:");
residentialProperty.display(); // Display details of the residential property
System.out.println("\nCommercial Property Details:");
commercialProperty.display(); // Display details of the commercial property
}
}
Copy code

Output

Residential Property Details:
Address: 123 Maple St
Square Feet: 1500.0
Bedrooms: 3
Bathrooms: 2

Commercial Property Details:
Address: 456 Oak St
Square Feet: 3000.0
Lease Type: Triple Net
Business Type: Retail

The output of the program demonstrates hierarchical inheritance in Java through the following:

  • The Property class serves as the base, holding common attributes (address, squareFeet) and a method (display()) for all property types.
  • Residential and Commercial classes inherit from Property and add unique attributes (bedrooms, bathrooms for Residential; leaseType, businessType for Commercial), showcasing specialization.
  • Both derived classes override the display() method to include their specific attributes, in addition to those inherited from Property.
  • Upon execution, instances of Residential and Commercial are created and populated with specific details. Invoking their display() methods outputs the comprehensive property details to the console.

Mastering Multilevel Inheritance in Java
Mastering Multilevel Inheritance in Java
Do you know multi-level inheritance in Java simplifies building complex systems by letting classes inherit features and behaviours from their ancestors? This method enhances code efficiency and maintainability, enabling developers...read more

Why Multiple Inheritance is Not Supported in Java?
Why Multiple Inheritance is Not Supported in Java?
Have you ever wondered why Java doesn't support multiple inheritance directly? The primary reason is to avoid complexity and ambiguity in the inheritance hierarchy, especially problems like the diamond issue....read more

Difference Between Inheritance and Polymorphism
Difference Between Inheritance and Polymorphism
Have you ever wondered the difference between inheritance and polymorphism in OOP? Inheritance creates class hierarchies for code reuse, while polymorphism enables flexible interactions using shared interfaces. Let's understand more!...read more

Difference Between Multilevel and Multiple Inheritance
Difference Between Multilevel and Multiple Inheritance
Have you ever wondered about the difference between multilevel and multiple inheritance in OOP? Multilevel follows a parent-child chain for extending classes, while multiple allows a class to inherit features...read more

Uses and Applications of Hierarchical Inheritance in Java

Application Area

Explanation

User Role Management

In a system requiring different user roles (e.g. Admin, Editor, Viewer), hierarchical inheritance allows these roles to inherit common methods and properties from a User class, while also implementing role-specific functionalities.

Product Category System

For an e-commerce platform, a base Product class can be extended by specific product categories like Electronics, Clothing, Grocery, each subclass can have additional properties like warranty for electronics, size for clothing, etc.

Animal Taxonomy

In a biological classification system, a LivingOrganism class could be extended by various animal classes (Mammal, Bird, Fish), with each subclass inheriting common traits while introducing species-specific behaviors and attributes.

UI Component Library

A user interface library might have a generic UIComponent class that is extended by specific components like Button, TextBox, and DropdownMenu, each subclass adds UI-specific logic while sharing base rendering logic.

Notification System

A notification system could have a base Notification class that provides basic notification functionalities, extended by EmailNotification, SMSNotification, and PushNotification, each implementing medium-specific delivery methods.

Thus, Hierarchical inheritance in Java effectively demonstrates how a single parent class can serve as the foundation for multiple child classes, each inheriting common properties while also introducing their unique characteristics.

Check out Java Courses Here!

FAQs

What is Hierarchical Inheritance in Java?

Hierarchical inheritance in Java is a type of inheritance where a single parent class is extended by multiple child classes. Each child class inherits the properties and methods of the parent class but can also define its own unique features. This model allows for code reuse and the extension of base functionalities across different subclasses.

How does Hierarchical Inheritance differ from Multilevel Inheritance?

Hierarchical inheritance involves a single parent class being extended by multiple child classes, each with its own set of features. In contrast, multilevel inheritance involves a chain of classes where a class is derived from another derived class, forming a parent-child-grandchild relationship. While hierarchical inheritance focuses on a single level of multiple inheritances from one class, multilevel inheritance emphasizes a linear inheritance path through several generations.

Can Hierarchical Inheritance lead to any issues in Java?

While hierarchical inheritance promotes code reuse and organization, it can lead to complexity if not properly managed. A common issue is the potential for method overriding confusion, where a child class redefines a method from the parent class, leading to unexpected behavior if not carefully documented and understood. Additionally, excessive inheritance can complicate the code structure and increase the learning curve for new developers joining a project.

How can Hierarchical Inheritance be implemented effectively in Java?

To implement hierarchical inheritance effectively in Java, it's important to follow best practices such as keeping the parent class' design simple and focused, ensuring clear documentation for any overridden methods, and avoiding deep inheritance trees that can make maintenance difficult. Utilizing interfaces and abstract classes can also help define clear contracts for your subclasses and provide a flexible architecture.

What are some real-world examples where Hierarchical Inheritance is used in Java?

 A classic example of hierarchical inheritance in Java is the development of a GUI (Graphical User Interface) component library, where a generic Component class provides basic functionality like size and visibility, and specific component classes like Button, TextField, and CheckBox extend it with additional features. Another example is an organizational management system where an Employee base class provides common attributes and methods, and specific roles like Manager, Engineer, and Technician extend the Employee class to include role-specific data and behaviors.

About the Author
author-image
Esha Gupta
Associate Senior Executive

Hello, world! I'm Esha Gupta, your go-to Technical Content Developer focusing on Java, Data Structures and Algorithms, and Front End Development. Alongside these specialities, I have a zest for immersing myself in v... Read Full Bio