Object-Oriented Programming: Polymorphism and Encapsulation

Polymorphism in Python

Polymorphism is a key concept in object-oriented programming that allows objects of different classes to be treated as objects of a common superclass. This means that a single interface can be used to represent multiple types of objects, enabling code reuse and flexibility in design. Polymorphism is achieved through method overriding and method overloading in Python.

Method Overloading

Method overloading is a feature of Python that allows a class to define multiple methods with the same name but different parameters. When a method is called, Python determines which method to execute based on the number and types of arguments passed to the method. This allows you to define methods that perform different operations based on the input arguments.

Here’s an example of method overloading in Python:

class Calculator:
    def add(self, a, b):
        return a + b

    def add(self, a, b, c):
        return a + b + c

# Create an instance of the Calculator class
calc = Calculator()

# Call the add method with two arguments

print(calc.add(10, 20)) # Output: 30

# Call the add method with three arguments
print(calc.add(10, 20, 30)) # Output: 60

In this example, the Calculator class defines two add methods with different numbers of arguments. When the add method is called with two arguments, the first method is executed, and when it is called with three arguments, the second method is executed. This demonstrates method overloading in Python.

Encapsulation and Property Decorators

Encapsulation is another important concept in object-oriented programming that involves bundling the data (attributes) and methods that operate on the data into a single unit called a class. Encapsulation helps in hiding the internal state of an object and protecting it from external interference. In Python, encapsulation is achieved through access control mechanisms such as private attributes and methods.

One way to implement encapsulation in Python is by using property decorators. Property decorators allow you to define getter, setter, and deleter methods for class attributes, providing controlled access to the attributes.

Here’s an example of encapsulation using property decorators in Python:

class Person:
    def __init__(self, name, age):
        self._name = name
        self._age = age

    @property
    def name(self):
        return self._name

    @property
    def age(self):
        return self._age

    @age.setter
    def age(self, value):
        if value < 0:
            raise ValueError("Age cannot be negative")
        self._age = value

    @age.deleter
    def age(self):
        del self._age

# Create an instance of the Person class
person = Person("Alice", 30)

# Access the name attribute
print(person.name) # Output: Alice

# Access the age attribute
print(person.age) # Output: 30

# Update the age attribute
person.age = 35
print(person.age) # Output: 35

# Delete the age attribute
del person.age

In this example, the Person class defines private attributes _name and _age and uses property decorators to define getter, setter, and deleter methods for the name and age attributes. This allows controlled access to the attributes and ensures that the age attribute cannot be set to a negative value.

Encapsulation and property decorators are powerful tools in Python that help in building robust and maintainable object-oriented code. By encapsulating data and providing controlled access to it, you can ensure data integrity and prevent unauthorized access to object attributes. Property decorators provide a clean and concise way to implement encapsulation in Python classes.

Conclusion

In this tutorial, we explored the concepts of polymorphism and encapsulation in object-oriented programming using Python. We learned about method overloading, which allows a class to define multiple methods with the same name but different parameters, and how polymorphism enables objects of different classes to be treated as objects of a common superclass. We also discussed encapsulation and property decorators, which help in hiding the internal state of an object and providing controlled access to object attributes.