13.1 Inheritance basics

Object-oriented design relationships are crucial in Python programming. They help organize code and create efficient, reusable structures. Understanding is-a and has-a relationships, along with superclass and subclass hierarchies, is key to building robust object-oriented systems.

Implementing inheritance allows for code reuse and specialization. By defining parent and child classes, programmers can create complex structures that mirror real-world relationships. This approach enhances code organization and promotes modularity in software development.

Object-Oriented Design Relationships

Is-a vs has-a relationships

• Is-a relationship represents inheritance between classes indicates one class is a specialized version of another (Car is a Vehicle)
• Has-a relationship represents composition or aggregation between classes indicates one class contains or is composed of another (Car has an Engine)

Superclass and subclass hierarchy

• Superclass (parent class or base class) more general class contains common attributes and methods provides blueprint for subclasses to inherit from can be inherited by multiple subclasses
• Subclass (child class or derived class) more specialized class inherits attributes and methods from superclass can add new attributes and methods specific to subclass can override or extend functionality of inherited methods
• Inheritance hierarchy represents relationship between superclasses and subclasses subclasses inherit from superclasses creating hierarchical structure allows code reuse and creation of specialized classes based on more general ones

Implementation of inheritance

• Defining parent class
  1. Create class containing common attributes and methods
  2. Use

     class

     keyword followed by class name
  3. Example:

     class Vehicle:
         def [__init__](https://www.fiveableKeyTerm:__init__)([self](https://www.fiveableKeyTerm:self), make, model):
             self.make = make
             self.model = model
         
         def start_engine(self):
             print("Starting the engine")
     

• Defining child class
  1. Create class inheriting from parent class
  2. Use

     class

     keyword followed by class name and parent class name in parentheses
  3. Example:

     class Car(Vehicle):
         def __init__(self, make, model, num_doors):
             [super()](https://www.fiveableKeyTerm:super()).__init__(make, model)
             self.num_doors = num_doors
         
         def honk(self):
             print("Honk honk!")
     

• Using parent and child classes
  • Create instances of child class which inherit attributes and methods from parent class
  • Access inherited attributes and methods using dot notation
  • Example:

    my_car = Car("Toyota", "Camry", 4)
    my_car.start_engine()  # Inherited from Vehicle
    my_car.honk()  # Specific to Car
    

Object-Oriented Programming Concepts

• Object-oriented programming is a programming paradigm that organizes code into objects, which are instances of classes
• Abstraction: Simplifying complex systems by modeling classes based on essential properties and behaviors
• Encapsulation: Bundling data and methods that operate on that data within a single unit or object
• Method resolution order: The order in which Python searches for methods in a class hierarchy during inheritance