Inheritance in Java

Java Inheritance is a fundamental concept in OOP(Object-Oriented Programming). It is the mechanism in Java by which one class is allowed to inherit the features(fields and methods) of another class. In Java, Inheritance means creating new classes based on existing ones. A class that inherits from another class can reuse the methods and fields of that class. In addition, you can add new fields and methods to your current class as well.

Why Use Inheritance in Java?Code Reusability: The code written in the Superclass is common to all subclasses. Child classes can directly use the parent class code.
Method Overriding: Method Overriding is achievable only through Inheritance. It is one of the ways by which Java achieves Run Time Polymorphism.
Abstraction: The concept of abstraction where we do not have to provide all details, is achieved through inheritance. Abstraction only shows the functionality to the user.
that Organizes classes in a structured manner, improving readability and maintainability.

Key Terminologies Used in Java Inheritance:

Class: Class is a set of objects that share common characteristics/ behavior and common properties/ attributes. Class is not a real-world entity. It is just a template or blueprint or prototype from which objects are created.
Super Class/Parent Class: The class whose features are inherited is known as a superclass(or a base class or a parent class).
Sub Class/Child Class: The class that inherits the other class is known as a subclass(or a derived class, extended class, or child class). The subclass can add its own fields and methods in addition to the superclass fields and methods.
Extends Keyword: This keyword is used to inherit properties from a superclass.
Method Overriding: Redefining a superclass method in a subclass.
Reusability: Inheritance supports the concept of “reusability”, i.e. when we want to create a new class and there is already a class that includes some of the code that we want, we can derive our new class from the existing class. By doing this, we are reusing the fields and methods of the existing class.

How Inheritance Works in Java?

The extends keyword is used for inheritance in Java. It enables the subclass to inherit the fields and methods of the superclass. When a class extends another class, it means it inherits all the non-primitive members (fields and methods) of the parent class, and the subclass can also override or add new functionality to them.

Inheritance in Java Example:

// Java program to illustrate the
// concept of inheritance

// base class
class Bicycle {
// the Bicycle class has two fields
public int gear;
public int speed;

// the Bicycle class has one constructor
public Bicycle(int gear, int speed)
{
    this.gear = gear;
    this.speed = speed;
}

// the Bicycle class has three methods
public void applyBrake(int decrement)
{
    speed -= decrement;
}

public void speedUp(int increment)
{
    speed += increment;
}

// toString() method to print info of Bicycle
public String toString()
{
    return ("No of gears are " + gear + "\n"
            + "speed of bicycle is " + speed);
}

}

// derived class
class MountainBike extends Bicycle {

// the MountainBike subclass adds one more field
public int seatHeight;

// the MountainBike subclass has one constructor
public MountainBike(int gear, int speed,
                    int startHeight)
{
    // invoking base-class(Bicycle) constructor
    super(gear, speed);
    seatHeight = startHeight;
}

// the MountainBike subclass adds one more method
public void setHeight(int newValue)
{
    seatHeight = newValue;
}

// overriding toString() method
// of Bicycle to print more info
@Override public String toString()
{
    return (super.toString() + "\nseat height is "
            + seatHeight);
}

}

// driver class
public class Test {
public static void main(String args[])
{

    MountainBike mb = new MountainBike(3, 100, 25);
    System.out.println(mb.toString());
}

}