Data Structures and Algorithms

by Albert Major

Inheritance Basics in OOP

What is Inheritance?

• Definition: Inheritance is about creating specialized classes (subclasses) from more general classes (superclasses).
• “Is-a” relationship:
  • If Student inherits from Person, we say “A student is a person.”
  • The subclass (e.g., Student) has all attributes/methods of the superclass (Person) and can add or modify functionality.
• Why use inheritance?
  • Avoid rewriting code. You reuse existing methods/attributes from the parent (superclass).
  • Logical organization of classes. A subclass extends or slightly changes what the superclass has.

Syntax and Basic Examples

• Defining a subclass:

  class LandVehicle(Vehicle):
      # This means LandVehicle inherits from Vehicle
      pass
  
  

• Overriding methods:

  • You can override the superclass’s methods (like __init__ or any other method) in your subclass.

  • If you override __init__, you can call the original (superclass) __init__ with:

    super().__init__(param1, param2, ...)
    
    

• Adding new methods/attributes:

  • Subclasses can have their own unique methods/attributes that do not exist in the superclass.

Examples with Vehicles

1. General Vehicle class

   • Has a name and a maximum speed.

   • Demonstrated using __init__, __repr__ (or __str__) for printing.

   • Example:

     class Vehicle:
         def __init__(self, name, max_speed):
             self.name = name
             self.max_speed = max_speed
     
         def __repr__(self):
             return f"{self.name}, {self.max_speed}"
     
     

2. Subclass LandVehicle (inherits from Vehicle):

   • You can store an extra attribute, e.g. the number of wheels.

   • Overriding the __init__:

     class LandVehicle(Vehicle):
         def __init__(self, name, max_speed, wheels):
             super().__init__(name, max_speed)   # call Vehicle's __init__
             self.wheels = wheels
         # Possibly override __repr__ or add new methods
     
     

3. Subclass WaterVehicle (inherits from Vehicle):

   • Could have a different interpretation of speed (e.g., “knots” instead of km/h).
   • Demonstrates overriding the __init__ or adding methods, like def knots(self):.

4. Additional Subclasses

   • You can create Car(LandVehicle), Bicycle(LandVehicle), Cruiser(WaterVehicle), etc.
   • Each subclass can override methods or attributes as needed (e.g., a bicycle always has 2 wheels, a car might have 4).

Calling Methods in the Inheritance Chain

• super() usage:

  • When you override a method, you can still call the superclass’s version of that method to avoid duplicating code.

  • For example:

    class Bicycle(LandVehicle):
        def __init__(self, name, max_speed):
            # We know a bicycle always has 2 wheels, so we fix that:
            super().__init__(name, max_speed, wheels=2)
    
    

• Class-method calls (rarely used in modern Python):

  • You can directly call a specific superclass’s method by referencing the class name, for example:

    Vehicle.__init__(self, name, max_speed)
    
    

  • But this can lead to confusing “spaghetti code.” Generally super() is cleaner.