Object Oriented Programming – Abstraction

What is Abstraction?

Abstraction is a fundamental concept in Object-Oriented Programming (OOP) that focuses on hiding the internal implementation details of a class or method while exposing only the necessary functionality. This simplifies code interaction, reduces complexity, and enhances maintainability.

In Python, abstraction is achieved using abstract classes and abstract methods, which are defined in the abc module.

Abstract Classes and Methods

An abstract class serves as a blueprint for other classes. It cannot be instantiated directly and must be subclassed. Abstract classes contain one or more abstract methods, which are declared but not implemented. Subclasses must provide their own implementation for these methods.

For example:

from abc import ABC, abstractmethod
# Abstract class
class Animal(ABC):
   @abstractmethod
   def make_sound(self):
       pass # Abstract method with no implementation
# Concrete subclass
class Dog(Animal):
   def make_sound(self):
       return "Bark"
# Instantiate the subclass
dog = Dog()
print(dog.make_sound()) # Output: Bark

In this example, Animal is an abstract class with an abstract method make_sound(). The Dog class implements the method, allowing it to be instantiated.

Key Components of Abstraction

1. Abstract Methods: Declared using the @abstractmethod decorator, these methods must be implemented by subclasses.
2. Concrete Methods: Fully implemented methods in an abstract class that can be inherited by subclasses.
3. Abstract Properties: Declared using @property and @abstractmethod, these enforce property implementation in subclasses.

Example of Abstract Properties

from abc import ABC, abstractmethod
class Vehicle(ABC):
   @property
   @abstractmethod
   def wheels(self):
       pass
class Car(Vehicle):
   @property
   def wheels(self):
       return 4
car = Car()
print(car.wheels) # Output: 4

Here, wheels is an abstract property in the Vehicle class, and the Car class provides its implementation.

Benefits of Abstraction

• Simplifies Code: Users interact with high-level functionality without worrying about internal details.
• Encapsulation: Sensitive or unnecessary details are hidden, reducing misuse or accidental changes.
• Flexibility: Subclasses can define specific behaviors while adhering to a consistent structure.
• Maintainability: Internal changes in abstract classes do not affect external code.

Important Considerations

• Abstract classes cannot be instantiated directly. Attempting to do so raises a TypeError.
• Subclasses must implement all abstract methods and properties; otherwise, they too become abstract and cannot be instantiated.

Example of Instantiation Error

from abc import ABC, abstractmethod
class Shape(ABC):
   @abstractmethod
   def area(self):
       pass
# Attempting to instantiate an abstract class
shape = Shape() # Raises TypeError

Abstraction in Python is a powerful tool for designing robust and scalable applications by enforcing a clear structure and hiding unnecessary complexity.