Java Inheritance Concepts

Inheritance

In Java programming language, inheritance is a mechanism in which one class acquires the properties of another. The class that inherits from others is called the subclass or child class, while the class being inherited from is referred to as the superclass or parent class. Inheritance allows for code reuse and organization of classes into hierarchies reflecting their real-world relationships.

Types of Inheritance

There are two types of inheritance in Java: single and multi-level inheritance.

Single Inheritance

In this type of inheritance, one subclass inherits properties from only one superclass. For example, the SubClass extends BaseClass.

public abstract class BaseClass<T extends BaseClass<T>> {
    // Code here
}

public class SubClass extends BaseClass<SubClass> {
    // Code here
}

Multi-Level Inheritance

Multi-level inheritance occurs when there is more than one level of inheritance within a hierarchy. This means that a subclass can extend another subclass which may again inherit properties from yet another subclass. However, due to limitations in Java's inheritance model, you cannot directly implement multi-level inheritance with methods like getThis() and method1(). You would need to use interfaces or other design patterns to achieve similar functionality.

Super Keyword

The super keyword in Java provides access to the superclass instance variables, methods, and constructors. It is used primarily to refer to the superclass in method overriding scenarios. The super keyword can also be utilized to provide access to the superclass's default methods and fields.

Method Overriding

Method overriding is a mechanism in object-oriented programming where a subclass provides a specific implementation of a method that is already provided by its superclass. This allows for polymorphism and behavior customization without modifying the original code. In order to override a method, the overriding method should have the same name, return type (or covariant), and parameter list as the parent's method.

Covariant Return Type

Covariant return types allow for changes to the return type when overriding methods. Before JDK 5.0, it was not possible to change the return type of an overridden method. However, with the introduction of covariant return types, it became possible to have different return types for an overriding method in the child class, but the child’s return type should be a subtype of the parent’s return type.

public abstract class Base {
    public Object fun() {
        // Code here
        return new Object();
    }
}

public class Derived extends Base {
    @Override
    public String fun() {
        // Code here
        return "Hello, World!";
    }
}

Abstract Classes

An abstract class is a class that cannot be instantiated on its own. Instead, it serves as a template for creating other classes. An abstract class can contain both abstract and non-abstract methods. It can also define variables, constructors, and member classes. To create an instance of an abstract class, you must also provide concrete implementations of all abstract methods declared in the abstract class.

Abstract Methods

An abstract method is a method that does not have an implementation but has a declaration. It can be declared using the abstract keyword followed by the return type and the method signature. The name of the method should be unique within its class declaration.

Abstract Classes and Interfaces

In Java, an abstract class can implement multiple interfaces but cannot extend another abstract class or interface directly. However, it can use composition to achieve similar functionality by containing objects of other classes and implementing the desired functionality through those objects.

Liskov Substitution Principle

The Liskov substitution principle is a fundamental property of object-oriented programming that states that subtypes should be able to replace their base types without affecting the correctness of any program. This principle ensures that inheritance relationships are well-defined and consistent across different parts of a system.