Inheritance

Concept of inheritance

Inheritance is a core concept in Object-Oriented Programming that allows one class (called the child or subclass) to acquire the properties and behaviors (fields and methods) of another class (called the parent or superclass). It promotes code reuse, hierarchy, and a clear organizational structure in complex software systems.

Key Idea of Inheritance

• A subclass inherits the fields and methods of its superclass
• The subclass can use, override, or extend the functionality of the superclass
• This allows shared behavior across multiple related classes, reducing code duplication

Types of Inheritance

• Single Inheritance – A subclass inherits from one superclass
• Multiple Inheritance – A subclass inherits from more than one superclass (not supported directly in some languages like Java)
• Multilevel Inheritance – A subclass inherits from a class that is also a subclass of another class
• Hierarchical Inheritance – Multiple subclasses inherit from the same superclass
• Hybrid Inheritance – A combination of two or more types of inheritance

Benefits of Inheritance

• Encourages code reuse by allowing common functionality to be defined once in a base class
• Improves maintainability and reduces redundancy
• Enables polymorphism, allowing objects to be treated as instances of their superclass
• Helps build modular and scalable applications

Inheritance and Method Overriding

• A subclass can override methods of the superclass to provide specialized behavior
• This supports dynamic behavior and flexibility in object interactions

Inheritance in Real-World Modeling

• Example: A vehicle superclass with fields like speed and fuel
• Subclasses like car, truck, and bike inherit common behavior but also have specific features

Inheritance forms the foundation for building a hierarchical structure of classes, promoting reuse, reducing complexity, and making software more extensible and easier to manage.

Base and Derived classes

Base and derived classes are fundamental components of inheritance in Object-Oriented Programming. They define a relationship where one class inherits properties and behaviors from another, allowing for code reuse and logical organization of related entities.

What is a Base Class?

• A base class, also known as a superclass or parent class, is the general class from which other classes inherit
• It defines common fields and methods that are shared among derived classes
• Base classes provide a foundation of functionality that can be extended or reused
• Example: A person class with fields like name and age and methods like introduce

What is a Derived Class?

• A derived class, also called a subclass or child class, is created by inheriting from a base class
• It automatically receives the fields and methods of the base class
• The derived class can also introduce new fields and methods or override base class methods
• Example: A Student class that inherits from person and adds student id and study()

Inheritance Relationship

• Derived classes use the syntax of the language (like Extends Or 🙂 to inherit from base classes
• This relationship creates an “is-a” association, meaning a Student is a Person
• Multiple derived classes can inherit from the same base class

Method Overriding

• Derived classes can override methods of the base class to change or extend their behavior
• This is useful for customizing functionality while maintaining a shared interface

Encapsulation and Access

• Base class members can be protected or public to allow controlled access in derived classes
• Private members are not directly accessible by derived classes, preserving encapsulation

Real-World Example

• Animal (base class): has fields like species and age, and method Eat()
• Dog(derived class): inherits from Animal and adds method bark()
• Cat (derived class): inherits from Animal and adds method meow()

Base and derived classes promote efficient, reusable, and scalable code by leveraging inheritance. This structure enables developers to define generalized behavior once and extend it as needed in more specific contexts.

Method Overriding

Method Overriding

Method overriding is an object-oriented programming feature that allows a subclass to provide a specific implementation of a method that is already defined in its superclass. It enables polymorphism and dynamic method dispatch, allowing objects to behave differently based on their actual types, even when referenced by a base type.

Definition and Purpose

• Occurs when a derived class defines a method with the same name, return type, and parameters as a method in its base class
• Enables a subclass to provide a more specific or updated behavior for an inherited method
• Supports dynamic or runtime polymorphism

Requirements for Overriding

• The method in the subclass must have the same signature (name and parameter list) as in the base class
• The method must be accessible to the subclass (usually Protected or Public)
• The base class method should be marked as Virtual (in languages like C++) or should be designed for overriding (like using @Override in Java)

Key Characteristics

• Only instance (non-static) methods can be overridden
• Overridden methods in the subclass replace the behavior of the base class when called through a subclass object
• Polymorphism allows calling the overridden method using a reference to the base class, executing the derived class version

Benefits of Method Overriding

• Provides flexibility to modify or enhance inherited behavior in derived classes
• Supports the Open/Closed Principle by allowing extensions without modifying existing code
• Enables dynamic method resolution and customized responses in derived classes

Real-World Example

• A Shape base class has a method draw()
• Subclasses like Circle and Rectangle override the draw() method to provide shape-specific drawing logic
• When calling draw() on a reference to Shape., the correct version executes based on the actual object type

Difference from Method Overloading

• Overriding changes behavior in a subclass, while overloading defines multiple methods with the same name but different parameters in the same class

Method overriding plays a crucial role in implementing polymorphism and extensible design. It allows subclasses to define their own versions of inherited methods, leading to more flexible and dynamic applications.

The super or base keyword

The super or base keyword is used in object-oriented programming to access the properties and methods of a parent class from within a child class. It plays a key role in inheritance by allowing a subclass to interact with its superclass.

Purpose and usage

• Used to call the parent class constructor from the child class
• Allows the child class to access or extend methods and properties defined in the parent class
• Helps in reusing code and maintaining a clear class hierarchy

Super and Base in different languages

• In Java and JavaScript, the keyword is super
• In C#, the equivalent keyword is base

Calling parent class constructor

• super(arguments) or base(arguments) is used inside the subclass constructor to initialize the parent class
• This ensures the fields and setup from the parent class are properly applied before the subclass adds its own

Calling parent class methods

• super. method Name() or base. method Name() is used to call a method from the parent class that is overridden in the subclass
• This is helpful when you want to preserve the original behavior and add more on top of it

Example scenario

• A class Vehicle has a method start Engine
• A class Car extends Vehicle and overrides start Engine
• Inside Car’s version of start Engine, calling super. start Engine() allows it to run the Vehicle’s version first

Best practices

• Use super or base for constructor chaining and avoiding code duplication
• Keep class hierarchies shallow and organized to make the use of these keywords simple and clear

The super or base keyword provides a reliable way to access and build upon existing functionality from a parent class, encouraging code reuse and structured design in object-oriented systems.