Inheritance

Inheritance is the OOP mechanism by which one class (the subclass or derived class) acquires the state variables and behaviors of another class (the superclass or base class). It establishes an "Is-A" relationship, facilitating structured code reuse.

1. Learning Objectives

• Establish hierarchical relationships using base and derived classes.
• Understand constructor chaining and class execution order.
• Differentiate between the structural implications of Inheritance vs Composition.

2. Problem Statement

Without inheritance, modeling different types of objects in the same domain leads to massive duplication. If you build an Employee Payroll System, you would copy-paste fields like id, name, and salary across FullTimeEmployee, PartTimeEmployee, and Contractor classes, multiplying technical debt.

3. Real-world Analogy

4. Theory

Inheritance defines how properties cascade down parent-child boundaries:

• Superclass (Base Class): Contains shared states and routines.
• Subclass (Derived Class): Inherits public/protected members, and can override behaviors or add properties.
• Constructor Chaining: When instantiating a subclass, the parent constructor executes first (using super() in Java) to initialize inherited attributes.
• Single vs Multiple Inheritance: Java restricts classes to single inheritance to prevent the Diamond Problem (resolving conflicts when inheriting identical methods from two parents). C++ supports multiple inheritance directly.

5. Visual Diagrams (UML & Memory structures)

Class Diagram

Object Diagram

Memory Diagram

Object Lifecycle

6. Syntax Explanation

• Java: Uses extends to establish inheritance. Accesses parent constructor using super(...).
• Python: Passes the base class name inside subclass parameters: class FullTimeEmployee(Employee):. Calls parent constructor via super().__init__(...).
• C++: Declares accessibility namespaces during inheritance: class FullTimeEmployee : public Employee. Passes variables up to base constructors inside initialization lists.

7. Step-by-Step Implementation

Let's build a hierarchical Employee Payroll System:

• Step 1: Declare base class Employee with protected variables name and baseSalary.
• Step 2: Declare a constructor initializing both base variables.
• Step 3: Build a subclass FullTimeEmployee extending Employee and declaring a subclass field bonus.
• Step 4: Invoke super(...) inside the subclass constructor to link instantiation.
• Step 5: Override the calculatePay() method inside the subclass to combine salary and bonus values.

8. Complete Code (Mini Project)

9. Code Walkthrough

FullTimeEmployee inherits name and baseSalary properties from the base class Employee. During initialization, super(name, baseSalary) runs the parent constructor. The @Override annotation flags the compiler to route calculations to the child's method at runtime.

10. Execution Flow

• Call subclass constructor.
• Trigger base parent class constructor to map base variables on the heap.
• Subclass constructor binds child attributes.
• Call calculatePay(), yielding combined values polymorphically.

11. Internal Working

In memory, the subclass object does not contain two nested instances. The JVM allocates one flat composite memory block in the Heap that contains both the parent's fields (name, baseSalary) and the child's fields (bonus).

12. Complexity Analysis

• Time Complexity: $O(1)$ to instantiate objects and access fields.
• Space Complexity: $O(1)$ constant allocation per object.

13. Best Practices

• Favor Composition over Inheritance: Use inheritance only when a strict, permanent "Is-A" relationship is present. Otherwise, use composition ("Has-A").
• Keep hierarchies shallow: Keep class hierarchies to 2 or 3 levels maximum. Deep hierarchies are difficult to maintain.

14. Common Mistakes

• Violating the Liskov Substitution Principle (LSP) by changing the expected behavior of base methods in a way that breaks client code.
• Inheriting from a class just to reuse its helper methods when no conceptual "Is-A" link exists.

15. Interview Questions

16. Practice Exercises

• Easy: Add a subclass Contractor that calculates pay based on hours worked and an hourly rate.
• Medium: Add validation inside the Employee constructor to prevent null names or negative base salaries. Ensure this validation runs when subclasses are instantiated.
• Hard: Redesign the system to calculate pay using composition (a PayrollStrategy class injected at runtime) instead of class inheritance, comparing the trade-offs of both designs.

17. Challenge Problem

Design a vehicle rental hierarchy (VEHICLE base, CAR child, TRUCK child) with dynamic surcharge computations based on vehicle weight and dimensions.

18. Summary

• Inheritance establishes an "Is-A" relationship between classes.
• Constructor chaining ensures parent attributes are initialized before subclass execution.
• Subclasses are stored as flat, single objects containing both parent and child fields in heap memory.

19. Cheat Sheet

20. Quiz

21. Next Lesson Preview

In the next lesson, we will explore Polymorphism to master both compile-time method overloading and runtime method overriding!