Inheritance in JAVA

Inheritance is a crucial feature of Java that allows a class to inherit properties and methods from another class. It establishes a relationship between a parent class (superclass) and a child class (subclass). Think of it as a parent passing on traits to their offspring. Let's delve deeper into this concept.

Basic Inheritance Structure

At its core, inheritance forms an "is-a" relationship between classes. 

This means that a subclass is a specialized version of its superclass. 

For example, you can have a superclass called "Vehicle" and a subclass called "Car." A car is a type of vehicle, and that's where inheritance comes into play.

Types of Inheritance

1. Single Inheritance

In single inheritance, a class can inherit from only one superclass. This is a straightforward form of inheritance, and it's used when a class has a clear, singular parent.

2. Multiple Inheritance

Multiple inheritance allows a class to inherit from more than one superclass. While it offers flexibility, Java doesn't support it directly to avoid ambiguity in method and property resolution.

3. Multilevel Inheritance

In multilevel inheritance, a class acts as a subclass for another class, which, in turn, is a subclass for a third class. This forms a chain of inheritance, making the relationship more complex.

4. Hierarchical Inheritance

In hierarchical inheritance, multiple classes inherit from a single superclass. Each subclass shares common properties and methods, but they can also have their unique features.

---

Example of Inheritance

Let's illustrate inheritance with a practical example. Imagine we have a superclass called "Animal" with properties like "name" and "species." Now, we want to create a subclass called "Cat" that inherits these properties from "Animal" and adds its specific properties, such as "furColor" and "sound."

class Animal { String name; String species; } class Cat extends Animal { String furColor; String sound; }

In this example, "Cat" inherits the properties "name" and "species" from "Animal." This showcases how inheritance simplifies code by reusing existing classes.

Understanding the "extends" Keyword in Java

The "extends" keyword in Java is primarily used to create a subclass (or child class) that inherits properties and methods from a superclass (or parent class). It sets up what's known as an "is-a" relationship between the two classes. This means that the subclass is a specialized version of the superclass, and it can access and use the members (fields and methods) of the superclass.

Creating a Subclass

To use the "extends" keyword, you need to declare a class and specify the superclass from which you want to inherit. 

Here's a basic syntax example:

class Subclass extends Superclass { // Subclass members and methods }

In this example, "Subclass" is the name of the new class that you're creating, and "Superclass" is the name of the class you want to inherit from.

---

Inheriting Fields and Methods

When a subclass extends a superclass, it automatically inherits all the fields and methods defined in the superclass. This means that you can access these members directly within the subclass without having to redefine them. Here's an illustration:

class Animal { String name; void makeSound() { System.out.println("Animal makes a sound"); } } class Dog extends Animal { // Dog inherits the "name" field and "makeSound" method }

---

Method Overriding

While a subclass inherits methods from its superclass, it also has the option to provide its implementation for those methods. This process is called "method overriding." It allows the subclass to customize the behavior of the inherited method while preserving the method signature from the superclass.

class Animal { void makeSound() { System.out.println("Animal makes a sound"); } } class Dog extends Animal { @Override void makeSound() { System.out.println("Dog barks"); } }

In this case, the "Dog" class overrides the "makeSound" method from the "Animal" class to provide a more specific behavior.

---

Why Use "extends"?

The "extends" keyword and inheritance in general offer several advantages:

Code Reusability: Inheritance allows you to reuse code from existing classes, reducing redundancy and making your codebase more efficient.

Method Overriding: Subclasses can override methods from their superclasses, enabling customization while preserving the core functionality.

Polymorphism: Inheritance is a key element of polymorphism, where objects can take on multiple forms and be used interchangeably.

---

Single Inheritance

Single inheritance is the simplest form of inheritance, where a subclass extends a single superclass. 

In other words, a class inherits the properties and behaviours of only one class.

class Animal { void eat() { System.out.println("Animals eat food"); } } class Dog extends Animal { void bark() { System.out.println("Dogs bark"); } }

Output:

Animals eat food

Dogs bark

---

Multilevel Inheritance

Multilevel inheritance is a chain of inheritance where a class extends another class, which in turn extends another class.

In multilevel inheritance, you have a chain of classes where a subclass (derived class) inherits from another class, which in turn inherits from another class. 

An intermediate derived class is a class that is in the middle of this inheritance chain, between the base class and the final derived class.

Here class B is an intermediate derived class.

in short the class which is a super class and also is a sub class is called intermediate derived class.

(Here, class B is a sub class of class A and also a super class for class C)

class Grandparent { void grandparentMethod() { System.out.println("Grandparent method"); } } class Parent extends Grandparent { void parentMethod() { System.out.println("Parent method"); } } class Child extends Parent { void childMethod() { System.out.println("Child method"); } }

Output:

Grandparent method

Parent method

Child method

---

Hierarchical Inheritance

In hierarchical inheritance, multiple classes inherit from a single base class.

class Vehicle { void start() { System.out.println("Vehicle started"); } } class Car extends Vehicle { void drive() { System.out.println("Car is being driven"); } } class Bike extends Vehicle { void ride() { System.out.println("Bike is being ridden"); } }

Output:

Vehicle started

Car is being driven

Vehicle started

Bike is being ridden

---

Multiple Inheritance

Multiple inheritance allows a class to inherit from more than one superclass. Java does not support multiple inheritance directly through classes, but it can be achieved using interfaces.

interface A { void methodA(); } interface B { void methodB(); } class MyClass implements A, B { public void methodA() { System.out.println("Method A"); } public void methodB() { System.out.println("Method B"); } }

Output:

Method A

Method B

---

Hybrid Inheritance

Hybrid inheritance is a combination of two or more types of inheritance. It can be achieved by combining different types of inheritance mentioned above.

Example:

In a real-world scenario, hybrid inheritance can involve various combinations of single, multiple, multilevel, and hierarchical inheritance.

---