# Inheritance in Java Inheritance is one of the most important concepts of Object-Oriented Programming (OOP) and is used extensively in Java programming. It is a mechanism through which one class can acquire the properties and behaviours of another class. The class whose properties are inherited is called the superclass, parent class, or base class, while the class that inherits those properties is called the subclass, child class, or derived class. In Java, inheritance is mainly achieved using the `extends` keyword for classes. The main purpose of inheritance is to promote code reusability, reduce duplication, support method overriding, and establish a relationship between classes. For example, suppose there is a class called `Animal` containing common properties and methods such as `name`, `age`, and `eat()`. A class called `Dog` can inherit from `Animal` and use its properties and methods without defining them again. ```java class Animal { void eat() { System.out.println("Animal eats"); } } class Dog extends Animal { void bark() { System.out.println("Dog barks"); } } ``` In this example, `Dog` is a subclass of `Animal`. Therefore, an object of `Dog` can access the `eat()` method inherited from `Animal`, as well as its own `bark()` method. ```java Dog d = new Dog(); d.eat(); d.bark(); ``` Inheritance represents an "is-a" relationship. A dog is an animal, so `Dog` can inherit from `Animal`. Java inheritance therefore helps programmers model real-world relationships in a structured manner. Inheritance also supports method overriding. When a subclass provides its own implementation of a method that already exists in its superclass, it is called method overriding. This is an important feature for achieving runtime polymorphism. ```java class Animal { void sound() { System.out.println("Animal makes a sound"); } } class Dog extends Animal { @Override void sound() { System.out.println("Dog barks"); } } ``` Here, the `Dog` class changes the implementation of the `sound()` method inherited from `Animal`. When the method is called using a `Dog` object, the overridden version is executed. Java supports several forms of inheritance through classes, particularly single inheritance, multilevel inheritance, and hierarchical inheritance. Single inheritance occurs when one subclass inherits directly from one superclass. It is the simplest form of inheritance. ```java class Vehicle { void start() { System.out.println("Vehicle starts"); } } class Car extends Vehicle {