Why is it better to call back to a superclass method to run default actions, instead of copying and modifying its code in a subclass?

Inheritance is a powerful feature in Object-Oriented Programming (OOP) that allows one class, known as the subclass, to inherit properties and methods from another class called the superclass. This means that the subclass can use the functionalities of the superclass without having to rewrite the code. For example, if you have a superclass called `Animal` that has a method `eat()`, any class that inherits from `Animal` will have access to the `eat()` method. Inheritance promotes a hierarchical relationship between classes, enabling more organized and manageable code.

One of the major benefits of inheritance is code reuse. Rather than writing new code to perform tasks that have already been handled by a superclass, a subclass can simply call these existing methods. This not only saves time but also reduces errors, as the tested and verified code from the superclass is reused.
For instance, if a superclass `Vehicle` has a method `startEngine()`, all subclasses like `Car`, `Bike`, or `Truck` can reuse this method instead of implementing it independently. This approach not only makes the code cleaner but also keeps the implementation consistent across the subclasses.

Maintaining code becomes much simpler when using inheritance. Any updates or bug fixes made to a superclass method will automatically be available to all subclasses that use that method. This centralized approach ensures that changes propagate throughout the codebase without the need for multiple updates.
For example, modifying the `calculateSalary()` method in a `Employee` superclass will instantly apply these changes to all of its subclasses like `Manager`, `Engineer`, and `Intern`. This consistency is crucial for maintaining a robust and error-free codebase over time.

In OOP, the relationship between a superclass and a subclass is foundational. The superclass contains generalized methods and properties that can be extended by one or more subclasses. When a subclass inherits from a superclass, it can add new behaviors or modify existing ones. This process avoids code duplication and promotes a clear structure in programming.
For example, a `Bird` superclass might have a method `fly()`. A `Hawk` subclass could call the `fly()` method of the `Bird` class using `super.fly()`, while also adding new methods specific to hawks. This allows the `Hawk` class to benefit from the `Bird` class's established functionalities while adding its unique traits.