Inheritance in Java

Study Notes

Inheritance is a core concept in object-oriented programming, allowing classes to acquire properties and behaviors from other classes.
Establishes an IS-A relationship (parent-child) which promotes code reusability.
Enables new classes to be built upon existing classes by reusing methods and fields.

Class: A blueprint for creating objects with common properties.
Subclass/Child Class: Inherits features from another class; also known as derived or extended class.
Super Class/Parent Class: Class from which subclasses inherit; also known as base class.
Reusability: Mechanism allowing the use of existing fields and methods when creating new classes.

The syntax for creating a subclass is:

class Subclass-name extends Superclass-name {
    // methods and fields
}

The extends keyword indicates a new class derives functionality from an existing class.

In a scenario where the Programmer is a subclass of Employee:
- Programmer IS-A Employee
- Demonstrates code reusability as Programmer can access fields of both its class and its superclass.

Single Inheritance: One class inherits from another. Example: Dog inherits from Animal.
Multilevel Inheritance: A hierarchy where a class inherits from another class which itself is a subclass. Example: BabyDog inherits from Dog, which inherits from Animal.
Hierarchical Inheritance: Multiple classes inherit from a single superclass. Example: Dog and Cat both inherit from Animal.
Multiple Inheritance: Not supported through classes in Java but can be implemented using interfaces.

Runtime polymorphism is achieved through method overriding in subclasses.
Dynamic method dispatch allows calling the overridden method at runtime, based on the object's type.

Abstract Keyword: Used to declare a class that cannot be instantiated and may contain abstract methods that must be implemented by subclasses.
Final Keyword: Can be applied to classes, methods, and variables, preventing further modifications or extensions.

Defines a contract that classes can implement to adhere to specific behaviors.
Supports multiple inheritance through the implementation of multiple interfaces, facilitating more versatile and flexible code structures.