PikoPost
PikoPost β

24 Oct 2023

Beginner

There are several types of inheritance in OOP:

  1. Single Inheritance: In single inheritance, a class inherits from only one base class. This is the simplest form of inheritance, where a subclass derives its properties and behaviors from a single parent. Example of single inheritance, featuring a Vehicle base class and a Car subclass:

    • Base class: Vehicle
    • Subclass: Car
    • Description: The Car class inherits properties and behaviors from the Vehicle class, such as starting the engine.

    Base Class: Vehicle

    • Description: The Vehicle class represents a generic vehicle and includes attributes and methods common to all vehicles.
    +-------+
| Vehicle |
+-------+
| color |
| wheels |
| start_engine() |
| stop_engine()  |
+-------+

    Subclass: Car

    • Description: The Car class is a specific type of vehicle and inherits attributes and methods from the Vehicle class. It also includes additional features specific to cars.
    +-----+
|  Car |
+-----+
| model |
| fuel_type |
| drive() |
+-----+

    In this example:

    • The Vehicle class provides basic attributes such as color and wheels, along with methods for starting and stopping the engine.

    • The Car class inherits these attributes and methods from the Vehicle class and adds specific attributes such as model and fuel_type. It also includes a method drive() for car-specific functionality.

    This demonstrates single inheritance, where the Car class derives from the Vehicle class, inheriting and extending its attributes and methods to create a more specialized class for cars.

  2. Multiple Inheritance: Multiple inheritance allows a class to inherit attributes and behaviors from more than one base class.

    Example of multiple inheritance for classes representing animals, dogs, and puppies:

    Base Classes:

    • Animal: Represents generic attributes and behaviors of animals.
    • Dog: Represents attributes and behaviors specific to dogs.

    Subclass: Puppy

    • Description: The Puppy class is a subclass that inherits from both Animal and Dog. This subclass combines the characteristics of generic animals and dogs to represent young dogs, or puppies.
    +-------+
| Animal|
+-------+
| eat() |
| sleep()|
+-------+
   |
   |
   v
+----+
| Dog|
+----+
| bark()|
| wag_tail()|
+----+
   |
   |
   v
+--------+
| Puppy  |
+--------+
| eat()  | (Inherited from Animal)
| sleep()| (Inherited from Animal)
| bark()  | (Inherited from Dog)
| wag_tail()| (Inherited from Dog)
| play() | (Puppy-specific method)
+--------+

    In this example, the Puppy class inherits attributes and methods from both Animal and Dog. It can perform generic animal actions like eating and sleeping (inherited from Animal) and dog-specific actions like barking and wagging its tail (inherited from Dog). Additionally, it has a specific method, play(), which is unique to puppies. This demonstrates multiple inheritance in the context of animal, dog, and puppy classes.

  3. Multilevel Inheritance: Multilevel inheritance involves a chain of inheritance with multiple levels of classes. In this type of inheritance, a subclass inherits from a base class, and then another class inherits from this subclass. This forms a hierarchy of classes.

    Example of multilevel inheritance hierarchy:

    +---------+
|  Animal |
+---------+
|         |
|  eat()  |
|  move() |
+---------+
   |
   |
   v
+-------+
| Mammal|
+-------+
|        |
|  walk()|
|  sound()|
+-------+
   |
   |
   v
+------+
| Whale|
+------+
|      |
|  swim()|
|  sing()|
+------+

    In this modified example:

    • The Animal class defines basic methods like eat() and move() that all animals share.
    • The Mammal class inherits from Animal and adds specific methods for mammals, such as walk() and sound().
    • The Whale class inherits from Mammal and adds features specific to whales, such as swim and sing.

    This hierarchy still demonstrates multilevel inheritance, where each subclass builds upon the characteristics and behaviors of the class it inherits from, creating a more specialized class.

  4. Hierarchical Inheritance: In hierarchical inheritance, multiple classes inherit from a single base class. This means that multiple subclasses share a common parent class, allowing them to inherit its attributes and methods.

    Example of hierarchical inheritance with the Shape, Circle, Square, and Triangle classes:

    Base Class: Shape

    • Description: The Shape class represents a general category of shapes and includes methods to calculate the area and perimeter, although they may not have specific implementations since the calculation method depends on the shape.

    Subclasses: Circle, Square, and Triangle

    • Description: Each of these subclasses inherits from the Shape class. They share common properties and methods from the Shape class, but they also provide specific implementations of area and perimeter calculations for their respective shapes.
    +-------+
| Shape |
+-------+
| area()|
| perimeter()|
+-------+
     |
     |
     v
+--------+
| Circle |
+--------+
| radius |
| area() |
| perimeter() |
+--------+
     |
     |
     v
+--------+
| Square |
+--------+
| side   |
| area() |
| perimeter() |
+--------+
     |
     |
     v
+---------+
| Triangle |
+---------+
| base    |
| height  |
| area()  |
| perimeter() |
+---------+

    In this example, Circle, Square, and Triangle are subclasses of Shape. They inherit the common area() and perimeter() methods from the Shape class. However, each of them also has its specific attributes and methods for calculating the area and perimeter based on their respective shapes.

    This hierarchical inheritance structure represents a hierarchy of shapes, where each shape type inherits from the common Shape class, showcasing the relationship between these classes.

  5. Hybrid Inheritance: Hybrid inheritance is a combination of two or more types of inheritance mentioned above. It can include single, multiple, multilevel, or hierarchical inheritance within a single program.

    Example of hybrid inheritance involving the classes Employee, Student, Freelancer, and WorkingStudent:

    Base Classes:

    • Employee: Represents an individual who is employed in a company and has attributes and methods related to employment, such as salary calculation.
    • Student: Represents an individual who is pursuing education and has attributes and methods related to academic performance, such as grades.
    • Freelancer: Represents an individual who works on a freelance basis and has attributes and methods related to freelance work, such as project assignments.

    Subclass: WorkingStudent

    • Description: The WorkingStudent class is a subclass that inherits from both Employee and Student. This subclass represents an individual who is both employed and pursuing education. Additionally, WorkingStudent may inherit specific attributes or methods from Freelancer, illustrating hybrid inheritance.
    +-----------+
| Employee  |
+-----------+
| salary()  |
+-----------+
     |
     |
     v
+--------+
| Student|
+--------+
| grades |
+--------+
     |
     |
     v
+-----------+
| Freelancer|
+-----------+
| projects  |
+-----------+
     |
     |
     v
+---------------+
| WorkingStudent|
+---------------+
| salary()      |
| grades       |
| projects     |
+---------------+

    In this example, the WorkingStudent class inherits both employment-related attributes and methods from Employee and academic attributes and methods from Student. It may also inherit attributes and methods related to freelance work from Freelancer. This showcases hybrid inheritance, as WorkingStudent combines features from multiple base classes to represent an individual who is employed, pursuing education, and possibly freelancing.

object-oriented-programming
inheritance-types
arvi
arvi