Module 15 - More Object-Oriented Programming

Polymorphism is a powerful concept in Object-Oriented Programming (OOP) that allows objects of different classes to be treated as objects of a common superclass. It enables a single interface to represent various data types, promoting flexibility and code reuse. In Python, polymorphism is achieved through method overriding and duck typing.

How Polymorphism Works:

Polymorphism allows different classes to share a common interface or method name, even though they may have different implementations. When a method is called on an object, Python looks for that method in the object's class. If the method is not found in the class, Python searches the class hierarchy until it finds the method.

Method Overriding:

Method overriding is a form of polymorphism that occurs when a subclass provides a specific implementation for a method that is already defined in its superclass. The subclass overrides the behavior of the superclass method.

Example:

class Animal:
   def make_sound(self):
       return "Some generic sound."

class Dog(Animal):
   def make_sound(self):
       return "Woof! Woof!"

class Cat(Animal):
   def make_sound(self):
       return “Meow!”

In this example, the Animal class has a method make_sound(), which provides a generic sound. The Dog and Cat subclasses override this method with their specific sounds. When we call make_sound() on a Dog or Cat object, Python will use the overridden method from the corresponding subclass.

dog = Dog()
cat = Cat()

print(dog.make_sound())   # Output: "Woof! Woof!"
print(cat.make_sound())   # Output: “Meow!”

Duck Typing:

Python's dynamic typing system allows for a form of polymorphism called "duck typing." This means that if an object behaves like a certain type (quacks like a duck), it can be treated as that type without explicitly specifying its class inheritance.

Example:

class Car:
   def drive(self):
       print("Car is driving.")

class Bike:
   def drive(self):
       print("Bike is riding.")

def make_vehicle_drive(vehicle):
   vehicle.drive()

car = Car()
bike = Bike()

make_vehicle_drive(car)   # Output: "Car is driving."
make_vehicle_drive(bike)  # Output: “Bike is riding.”

In this example, we have two classes, Car and Bike, each with a drive() method. The function make_vehicle_drive() can take either a Car object or a Bike object and call the drive() method on it without caring about the specific class type.

Why Polymorphism is Useful:

• Flexibility: Polymorphism allows you to write more flexible and generic code that can handle different objects and data types without requiring explicit type checking.
• Code Reusability: By using a common interface, you can reuse the same code to work with different classes, reducing code duplication.
• Extensibility: You can easily add new classes that adhere to the common interface without modifying existing code, promoting scalability and maintainability.

When to Use Polymorphism:

Polymorphism is beneficial when you have multiple classes with similar behaviors or attributes but specific implementations. It is especially useful when you want to create generic functions or methods that can work with a variety of objects without needing to know their exact types.

Example:

Consider a Shape superclass with subclasses Rectangle and Circle. Each subclass has its own implementation of the area() method, demonstrating polymorphism.

class Shape:
   def area(self):
       pass

class Rectangle(Shape):
   def __init__(self, length, width):
       self.length = length
       self.width = width

   def area(self):
       return self.length * self.width

class Circle(Shape):
   def __init__(self, radius):
       self.radius = radius

   def area(self):
       return 3.14 * self.radius * self.radius

In this example, the area() method is defined in the Shape superclass but overridden in the Rectangle and Circle subclasses. When calling area() on objects of Rectangle or Circle, Python uses the specific implementation provided by each subclass, resulting in the correct area calculation.

rectangle = Rectangle(5, 3)
circle = Circle(4)

print(rectangle.area())  # Output: 15
print(circle.area())     # Output: 50.24

Polymorphism allows us to treat different shapes (Rectangle and Circle) uniformly as objects of the common superclass (Shape) and call the same method on them, making the code more flexible and reusable.

Polymorphism allows different objects to be treated uniformly based on their common behavior. It provides a consistent interface to different classes, making it easier to work with various objects using the same method calls.

Below is example code for a Vehicle Inventory System with Subclasses for Cars and Trucks, demonstrating Inheritance and Polymorphism:

# Define the parent class 'Vehicle'
class Vehicle:
   # Constructor method for initializing common attributes
   def __init__(self, make, model, year, last_service_date, odometer):
       self.make = make
       self.model = model
       self.year = year
       self.last_service_date = last_service_date
       self.odometer = odometer

   # Method to get the type of vehicle (to be overridden by subclasses)
   def get_vehicle_type(self):
       return "Generic Vehicle"

# Define the subclass 'Car' that inherits from 'Vehicle'
class Car(Vehicle):
   # Constructor method for initializing car-specific attributes and calling the parent constructor
   def __init__(self, make, model, year, last_service_date, odometer, num_doors):
       super().__init__(make, model, year, last_service_date, odometer)
       self.num_doors = num_doors

   # Override the get_vehicle_type() method to return the specific type of vehicle
   def get_vehicle_type(self):
       return "Car"

# Define the subclass 'Truck' that also inherits from 'Vehicle'
class Truck(Vehicle):
   # Constructor method for initializing truck-specific attributes and calling the parent constructor
   def __init__(self, make, model, year, last_service_date, odometer, payload):
       super().__init__(make, model, year, last_service_date, odometer)
       self.payload = payload

   # Override the get_vehicle_type() method to return the specific type of vehicle
   def get_vehicle_type(self):
       return "Truck"

Explanation of the Code Above:

1. class Vehicle: - Defines the parent class Vehicle which represents common attributes and behavior for all types of vehicles.
2. def __init__(self, make, model, year, last_service_date, odometer): - Defines the constructor method for the Vehicle class. It initializes common attributes such as make, model, year, last_service_date, and odometer.
3. self.make = make, self.model = model, etc. - Sets the values of the common attributes for each object created from the Vehicle class.
4. def get_vehicle_type(self): - Defines a method get_vehicle_type() within the Vehicle class. This method is intended to be overridden by subclasses and returns a generic type of vehicle.
5. class Car(Vehicle): - Defines the subclass Car that inherits from the Vehicle class. It represents cars and adds car-specific attributes.
6. def __init__(self, make, model, year, last_service_date, odometer, num_doors): - Defines the constructor method for the Car class. It calls the constructor of the parent class (Vehicle) using super() to initialize common attributes and sets the car-specific attribute num_doors.
7. super().__init__(make, model, year, last_service_date, odometer) - Calls the constructor of the parent class (Vehicle) to set common attributes for the Car object.
8. def get_vehicle_type(self): - Overrides the get_vehicle_type() method in the Car class. It returns the specific type of vehicle, which is "Car" in this case.
9. class Truck(Vehicle): - Defines the subclass Truck that also inherits from the Vehicle class. It represents trucks and adds truck-specific attributes.
10. def __init__(self, make, model, year, last_service_date, odometer, payload): - Defines the constructor method for the Truck class. It calls the constructor of the parent class (Vehicle) using super() to initialize common attributes and sets the truck-specific attribute payload.
11. super().__init__(make, model, year, last_service_date, odometer) - Calls the constructor of the parent class (Vehicle) to set common attributes for the Truck object.
12. def get_vehicle_type(self): - Overrides the get_vehicle_type() method in the Truck class. It returns the specific type of vehicle, which is "Truck" in this case.

Example of Polymorphism:

Now, let's demonstrate polymorphism by creating a list of vehicles (cars and trucks) and calling the get_vehicle_type() method for each vehicle. Despite having different subclasses, the method behaves uniformly for all objects in the list.

# Create a list of vehicles (cars and trucks)
vehicles = [
   Car("Toyota", "Corolla", 2021, "2023-07-15", 50000, 4),
   Truck("Ford", "F-150", 2020, "2023-07-10", 80000, 2000),
   Car("Honda", "Civic", 2019, "2023-07-20", 40000, 2),
   Truck("Chevrolet", "Silverado", 2018, "2023-07-05", 90000, 3000)
]

# Call the get_vehicle_type() method for each vehicle
for vehicle in vehicles:
   print(f"{vehicle.make} {vehicle.model} is a {vehicle.get_vehicle_type()}.")

Output:

Toyota Corolla is a Car.
Ford F-150 is a Truck.
Honda Civic is a Car.
Chevrolet Silverado is a Truck.

As shown in the output, the get_vehicle_type() method behaves uniformly for both cars and trucks, demonstrating polymorphism. This allows us to work with objects of different classes using a common interface, making the code more flexible and reusable.