Object-Oriented Programming - 3

Object-Oriented Programming (OOP) Overview

Object-oriented programming (OOP) is a programming paradigm built around the concept of "objects", which can represent real-world entities. OOP consists of several fundamental concepts:

  • Objects: Instances of classes that hold data and methods.

  • Classes: Templates for creating objects that encapsulate data and functionality.

  • Methods: Functions defined within classes that operate on the class's data.

  • Four Pillars of OOP: These are essential concepts to understand OOP in depth:

    • Encapsulation: Bundling of data and methods that work on that data within one unit, or class.

    • Abstraction: Hiding complex implementation details and showing only the essential features of an object.

    • Inheritance: Mechanism where a new class can inherit attributes and methods from an existing class.

    • Polymorphism: Ability of different classes to be treated as instances of the same class through a shared interface.

Inheritance in OOP

Inheritance allows subclasses (children) to inherit attributes and methods from a superclass (parent). This promotes modularity and reusability. Here are some important points:

  • All subclasses inherit attributes from the superclass.

  • Subclasses can override methods of the superclass, allowing for customized behavior.

  • Access to the parent class can be done using the super() function, while properties within the instance are accessed using self().

Example of Inheritance

Consider the following hierarchy:

  • Superclass: Vehicle

    • Subclass: Bus

    • Subclass: Car This structure helps in creating a hierarchy of classes that share common functionality.

Abstraction in OOP

Abstraction simplifies complex systems by exposing only the necessary parts. Key aspects include:

  1. Abstract classes cannot be instantiated directly.

  2. All abstract methods in an abstract class must be implemented by subclasses.

  3. Abstract classes may contain concrete methods (methods that are implemented).

  4. They can have static and class methods.

  5. They enforce a common interface across subclasses.

  6. Part of Python's ABC (Abstract Base Classes) module.

Example exercise using Abstraction

Design a program to model animals (like dogs, cats, birds) where each has methods like:

  • speak(): returns the sound the animal makes.

  • eat(): returns the food it eats.

  • set_name(): defines the animal's name.

Polymorphism in OOP

Polymorphism means "many forms". It allows for methods or functions to operate in different contexts, which leads to cleaner and more intuitive code. Key points include:

  • A single interface can refer to different underlying forms (data types).

  • Example: The move() method can be implemented in different ways for different classes like Car, Boat, and Plane.

Example of Polymorphism in Action

class Car:  
    def move(self):  
        print("Drive!")
 
class Boat:  
    def move(self):  
        print("Sail!")
 
class Plane:  
    def move(self):  
        print("Fly!")
 
for vehicle in (Car(), Boat(), Plane()):  
    vehicle.move()

In this example, all objects respond to the same move() method differently according to their class.

Method Overloading

Polymorphism also includes method overloading, which allows for multiple method definitions with the same name depending on input types. In Python, this can be accomplished by defining optional parameters:

class Area:  
    def find_area(self, side1=None, side2=None):  
        if side1 and side2:  
            print("Area of Rectangle:", side1 * side2)  
        elif side1:  
            print("Area of Square:", side1 * side1)

Operator Overloading

Similar to method overloading, operator overloading allows defining custom behavior for operators with user-defined objects. For example:

class Point:  
    def __add__(self, other):  
        return Point(self.x + other.x, self.y + other.y)

In this case, you can add two Point objects directly using the + operator.

Encapsulation in OOP

Encapsulation is the practice of keeping fields within a class private while providing controlled access via public methods. This protects the integrity of the data. The following access modifiers can be utilized:

  • Public: Accessible from anywhere.

  • Private: Accessible only within the class.

  • Protected: Accessible in the class and subclasses (indicated by a single underscore).

Example of Encapsulation

class Person:  
    def __init__(self, name, age):  
        self.__name = name  
        self.__age = age  
    def print_age(self):  
        print("Age:", self.__age)

In this example, __name and __age are private members, thus ensuring that they cannot be accessed directly.

Error Handling in Python

Errors in code are termed "bugs". Exception handling is vital to manage errors gracefully in a program. This can be implemented using try-except blocks, allowing the program to continue or deal with the error appropriately. Commonly used keywords in exception handling include:

  • try: the block of code where exceptions might occur.

  • except: handles the specific exceptions.

  • finally: defines a block of code that will always execute whether an exception occurred or not.

Example of Exception Handling

try:
    result = operand1 / operand2
except ZeroDivisionError:
    print("Check your dividend is zero")
finally:
    print("Cleanup tasks here")

This structure helps in maintaining program stability and debugging easier.