Java - Inheritance

 Inheritance in Java

Introduction to Java Inheritance

Java Inheritance is one of the most important Object-Oriented Programming (OOP) concepts that allows developers to create new classes based on existing classes. It promotes code reusability, improves maintainability, and reduces redundancy in Java applications. Inheritance helps developers build scalable, modular, and cleaner code structures for real-world applications like banking systems, e-commerce applications, school management tools, and enterprise software.In Java, inheritance enables a class to acquire the properties, methods, and behavior of another class. The class that inherits is known as the subclass or child class, and the class from which it inherits is known as the superclass or parent class. This concept lies at the heart of Java’s flexibility and has a major role in constructing frameworks, libraries, and reusable modules.

Why Inheritance Is Important in Java

Before diving deeper, it is essential to understand why inheritance is a core part of Java programming. Some key advantages include:

• Code Reusability: The child class can reuse fields and methods of the parent class without writing them again.
• Improved Maintainability: Updating code in one place updates functionality across all inherited classes.
• Method Overriding: Child classes can override parent methods to provide specific behavior, enabling runtime polymorphism.
• Hierarchical Structuring: Inheritance helps create logical relationships among classes.
• Faster Development: Since common functionality is reused, development time reduces significantly.

Basic Syntax of Java Inheritance

In Java, inheritance is implemented using the extends keyword. This keyword indicates that a class derives from another class.

class Parent {
    // parent class code
}

class Child extends Parent {
    // child class code
}

With this structure, the child class automatically receives access to all non-private fields and methods of the parent class.

Types of Inheritance in Java

Although Java does not support all types of inheritance directly, different forms are used widely in applications. Below are the major categories:

1. Single Inheritance

In single inheritance, one class inherits from one parent class. This is the simplest form of inheritance and is widely used in Java applications.

class Vehicle {
    void startEngine() {
        System.out.println("Engine started");
    }
}

class Car extends Vehicle {
    void carBrand() {
        System.out.println("Brand: Toyota");
    }
}

2. Multilevel Inheritance

In multilevel inheritance, a class inherits from another class, and then another class inherits from that derived class. It forms a chain-like structure.

class Animal {
    void eat() {
        System.out.println("Eating...");
    }
}

class Mammal extends Animal {
    void walk() {
        System.out.println("Walking...");
    }
}

class Dog extends Mammal {
    void bark() {
        System.out.println("Barking...");
    }
}

3. Hierarchical Inheritance

In hierarchical inheritance, multiple classes inherit from the same parent class. This is highly useful for creating large class hierarchies.

class Shape {
    void draw() {
        System.out.println("Drawing shape...");
    }
}

class Circle extends Shape {
    void area() {
        System.out.println("Area of Circle");
    }
}

class Rectangle extends Shape {
    void area() {
        System.out.println("Area of Rectangle");
    }
}

4. Multiple Inheritance (Not Supported with Classes)

Java does not support multiple inheritance using classes to avoid ambiguity problems such as the Diamond Problem. However, Java supports multiple inheritance using interfaces.

interface A {
    void display();
}

interface B {
    void show();
}

class Test implements A, B {
    public void display() {
        System.out.println("Display");
    }
    public void show() {
        System.out.println("Show");
    }
}

5. Hybrid Inheritance (Indirect)

Hybrid inheritance is a combination of multiple inheritance types. Java does not support this directly using classes but supports it through interfaces.

Key Concepts Related to Inheritance

Superclass and Subclass

A superclass (parent class) provides properties and methods that the subclass (child class) extends or inherits. The subclass can use the functionality of the parent class and can also introduce new behavior.

Access Modifiers and Inheritance

Access modifiers determine which members of a class can be inherited and accessed by child classes.

Constructor in Inheritance

Constructors are not inherited, but the constructor of the parent class is automatically called when creating an object of the child class.

class Parent {
    Parent() {
        System.out.println("Parent Constructor");
    }
}

class Child extends Parent {
    Child() {
        System.out.println("Child Constructor");
    }
}

public class Main {
    public static void main(String[] args) {
        Child c = new Child();
    }
}

Output:

Parent Constructor
Child Constructor

The super Keyword in Inheritance

The super keyword allows subclasses to refer to the superclass's fields, methods, and constructors.

1. Using super to call parent method

class Parent {
    void message() {
        System.out.println("Message from Parent");
    }
}

class Child extends Parent {
    void message() {
        super.message();
        System.out.println("Message from Child");
    }
}

2. Using super to call parent constructor

class Parent {
    Parent(String name) {
        System.out.println("Parent: " + name);
    }
}

class Child extends Parent {
    Child() {
        super("John");
        System.out.println("Child Constructor");
    }
}

Method Overriding in Inheritance

Method overriding occurs when a subclass provides a specific implementation of a method already defined in its parent class. It supports runtime polymorphism.

class Bank {
    int getRateOfInterest() {
        return 5;
    }
}

class SBI extends Bank {
    int getRateOfInterest() {
        return 8;
    }
}

class ICICI extends Bank {
    int getRateOfInterest() {
        return 9;
    }
}

IS-A Relationship in Java

Inheritance represents an IS-A relationship. Example: A Dog IS-A Animal, a Car IS-A Vehicle.

class Animal {}
class Dog extends Animal {}

HAS-A Relationship 

HAS-A represents a class containing another class as a member, not inheritance.

class Engine {}

class Car {
    Engine e = new Engine();
}

Final Keyword and Inheritance

1. final class

A final class cannot be inherited.

final class Vehicle {}
class Car extends Vehicle {} // Error!

2. final method

A final method cannot be overridden.

class A {
    final void display() {}
}
class B extends A {
    void display() {} // Error!
}

3. final variable

A final variable cannot be changed once initialized.

Examples of Inheritance in Java

1. University Management System

class Person {
    String name;
    int age;
}

class Student extends Person {
    int rollNo;
}

class Teacher extends Person {
    double salary;
}

2. E-Commerce Product Structure

class Product {
    String name;
    double price;
}

class Electronics extends Product {
    int warranty;
}

class Clothing extends Product {
    String size;
}

Rules of Inheritance in Java

• Private members are not inherited directly.
• Constructors are never inherited.
• Java does not support multiple inheritance using classes.
• Child class can access protected members of parent class.
• Object class is the root of Java inheritance hierarchy.

Java Inheritance is a powerful feature that plays an essential role in building large-scale object-oriented applications. It enhances code reusability, promotes cleaner project structures, and supports OOP concepts like polymorphism and abstraction. Understanding inheritance is vital for beginners, intermediate learners, and advanced developers working on enterprise-level Java applications. Mastery of inheritance leads to better software design, improved efficiency, and high-quality coding skills.