Inheritance in Java
Inheritance is a mechanism in Java where a new class, known as the subclass (or derived class), is derived from an existing class, known as the superclass (or base class).
The subclass inherits the fields and methods of the superclass, allowing it to reuse code and enhance or modify its behavior.
Inheritance is a fundamental principle of Object-Oriented Programming (OOP) that allows a class to inherit properties and behaviors from another class.
This enables code reuse and establishes a natural hierarchy between classes.
Key Characteristics of Inheritance
Reusability: Inheritance promotes code reusability by allowing a new class to reuse methods and fields of an existing class.
Hierarchy: It establishes a parent-child relationship between the superclass and the subclass.
Extensibility: The subclass can extend the functionalities of the superclass by adding new fields and methods or overriding existing ones.
Syntax of Inheritance
In Java, inheritance is achieved using the extends keyword.
class Superclass {
// Fields and methods of the superclass
}
class Subclass extends Superclass {
// Fields and methods of the subclass
}
Example of Inheritance
Let’s look at an example to understand how inheritance works.
Defining the Superclass
class Vehicle {
// Instance variables
String brand;
int wheels;
// Constructor
public Vehicle(String brand, int wheels) {
this.brand = brand;
this.wheels = wheels;
}
// Instance method
public void displayDetails() {
System.out.println("Brand: " + brand);
System.out.println("Number of Wheels: " + wheels);
}
}
Defining the Subclass
class Car extends Vehicle {
// Additional instance variable
int doors;
// Constructor
public Car(String brand, int wheels, int doors) {
super(brand, wheels); // Call to superclass constructor
this.doors = doors;
}
// Overriding method
@Override
public void displayDetails() {
super.displayDetails(); // Call to superclass method
System.out.println("Number of Doors: " + doors);
}
}
Using the Subclass
public class Main {
public static void main(String[] args) {
// Creating an object of the Car class
Car myCar = new Car("Toyota", 4, 4);
// Calling the displayDetails method
myCar.displayDetails();
}
}
Explanation:
Superclass (Vehicle): Contains fields brand and wheels, a constructor to initialize these fields, and a method displayDetails() to display vehicle details.
Subclass (Car): Inherits the Vehicle class, adds an additional field doors, and overrides the displayDetails() method to include the number of doors.
Using the Subclass: An object of the Car class is created, and the displayDetails() method is called to display the details of the car.
The output will be:
Brand: Toyota
Number of Wheels: 4
Number of Doors: 4
Inheritance Concepts
super Keyword
The super keyword in Java is used to refer to the superclass (parent) object.
It can be used to call superclass methods and constructors.
Calling Superclass Constructor: super(brand, wheels);
Calling Superclass Method: super.displayDetails();
Method Overriding
Method overriding allows a subclass to provide a specific implementation of a method that is already defined in its superclass.
@Override
public void displayDetails() {
// Overridden method implementation
}
Inheritance Hierarchy
Inheritance allows you to create a hierarchy of classes, where a subclass can have its own subclasses.
Example of Inheritance Hierarchy
class ElectricCar extends Car {
// Additional instance variable
int batteryCapacity;
// Constructor
public ElectricCar(String brand, int wheels, int doors, int batteryCapacity) {
super(brand, wheels, doors);
this.batteryCapacity = batteryCapacity;
}
// Overriding method
@Override
public void displayDetails() {
super.displayDetails();
System.out.println("Battery Capacity: " + batteryCapacity + " kWh");
}
}
Using the Inheritance Hierarchy
public class Main {
public static void main(String[] args) {
// Creating an object of the ElectricCar class
ElectricCar myElectricCar = new ElectricCar("Tesla", 4, 4, 100);
// Calling the displayDetails method
myElectricCar.displayDetails();
}
}
Explanation:
Superclass (Vehicle): Base class with basic vehicle details.
Subclass (Car): Extends Vehicle and adds additional attributes.
Sub-subclass (ElectricCar): Extends Car and adds battery capacity attribute, demonstrating a multi-level inheritance hierarchy.
The output will be:
Brand: Tesla
Number of Wheels: 4
Number of Doors: 4
Battery Capacity: 100 kWh
Advantages of Inheritance
Code Reusability: Reuse existing code, reducing redundancy.
Method Overriding: Customize or enhance existing methods.
Polymorphism: Achieve polymorphic behavior where a subclass instance can be treated as an instance of its superclass.
Extensibility: Easily extend existing code with new features.
Summary
Inheritance: Mechanism to derive a new class from an existing class, promoting code reuse and hierarchy.
Superclass and Subclass: Superclass is the base class, and subclass inherits from it.
extends Keyword: Used to define inheritance.
super Keyword: Used to refer to the superclass, call superclass methods, and constructors.
Method Overriding: Allows a subclass to provide a specific implementation of a superclass method.
Inheritance Hierarchy: Establishes a parent-child relationship across multiple levels.
Understanding inheritance is crucial for creating a hierarchical class structure and reusing code in your Java programs.