Abstraction Class & Interface OOPs In Python

In Python, abstract classes and interfaces are primarily used to define a blueprint for other classes. They allow you to create a common structure for classes while enforcing specific methods to be implemented in subclasses.

For example, if you want many classes to have a method called speak(), you can create an abstract class with a speak() method that doesn’t do anything yet. Then, any class that uses this abstract class must write its own version of the speak() method.

This is useful because it makes sure all related classes have the same structure and follow the same rules, which helps keep your code organized and easier to understand.

Abstract Class

An abstract class in Python is like a foundation blueprint for building other classes; you can’t create an object from it directly. It can include constructors, variables, abstract methods (which are rules that require subclasses to provide their own versions), and non-abstract methods (which already have code). When you create a new class based on an abstract class, that new class must implement the abstract methods, or it also becomes an abstract class. Essentially, an abstract class sets guidelines for subclasses, ensuring they follow a specific design.

Abstract Method

It is a method defined within an abstract class with no implementation details. Subclasses inheriting from the abstract class are required to provide their own implementation of this method.

Types of Methods in Terms of Implementation

Implemented Methods:

Implemented methods are regular methods that already have some code written inside them. These methods do something when called — they are not just empty or placeholders like abstract methods.

Example:

class Example:
    def implemented_method(self):
        print("This method is fully implemented.")

Un-implemented Methods (Abstract Methods)

Abstract methods are methods that don’t have any code inside them — they just have a name but no instructions. These methods are like a to-do list for any class that inherits them.

If you create a new class from an abstract class, you must write your own version of these abstract methods.

If you forget to do this, Python won’t let you create objects from that class.

These abstract methods are used to make sure every subclass has certain methods, even if each one works differently.

Example:

from abc import ABC, abstractmethod

class AbstractExample(ABC):
    @abstractmethod
    def unimplemented_method(self):
        pass

Declaring Abstract Methods

In Python, to declare an abstract method use the @abstractmethod decorator from the abc module. Here’s how to define an abstract class with both abstract and implemented methods:

Example:

from abc import ABC, abstractmethod

class AbstractBank(ABC):
    @abstractmethod
    def calculate_interest(self):
        pass

    def bank_info(self):
        print("Welcome to the bank.")

Example: Implementing an Abstract Class

class SavingsBank(AbstractBank):
    def calculate_interest(self):
        print("Interest for Savings Bank is 5%.")

class CurrentBank(AbstractBank):
    def calculate_interest(self):
        print("Interest for Current Bank is 3%.")

# Create instances of subclasses
savings = SavingsBank()
savings.bank_info()
savings.calculate_interest()

current = CurrentBank()
current.bank_info()
current.calculate_interest()

Output:

Welcome to the bank.
Interest for Savings Bank is 5%.
Welcome to the bank.
Interest for Current Bank is 3%.

Important Notes

Instantiation: We cannot create an instance of an abstract class. Attempting to do so will result in a TypeError.

# This will raise an error
bank = AbstractBank()  # TypeError: Can't instantiate abstract class AbstractBank with abstract methods calculate_interest

Subclasses: If a subclass does not implement all abstract methods, it also becomes an abstract class and cannot be instantiated.
Multiple Subclasses: An abstract class can be used by many different subclasses. Each subclass must write its own version of the abstract methods.

class HDFCBank(AbstractBank):
    def calculate_interest(self):
        print("Interest for HDFC Bank is 6%.")

Interface

Definition: It is a type of abstract class that contains only abstract methods (methods without a body).

Characteristics

In Python, interfaces are created using abstract classes with all abstract methods.
Interfaces can contain:
- Constructors
- Variables
- Abstract methods
- Subclasses
If a subclass does not implement all abstract methods of an interface, it becomes an abstract class.
Objects cannot be created from an interface; instead, objects can be instantiated from its subclasses that implement the abstract methods.

Key Features of Interfaces in Python

Defining a Contract: Interfaces specify a set of methods that any implementing class must define, ensuring a consistent and predictable API across different classes.
Multiple Inheritance: Python supports inheriting from multiple interfaces or base classes, allowing greater flexibility and enabling classes to combine behaviors from several sources.
Abstract Base Classes: Interfaces can be implemented using the abc module, which provides the infrastructure for defining abstract base classes.

Concrete Class

Definition: A concrete class is a class with all methods fully implemented.
When to Use: Use a concrete class when you have complete implementation details.

Usage Guidelines

Interface: Use when only requirement specifications are known, with no implementation details.
Abstract Class: Use when partial implementation is known but not fully defined.
Concrete Class: Use when complete implementation details are available.

Example of an Interface:

from abc import ABC, abstractmethod

# Define an interface using an abstract base class
class Animal(ABC):
    @abstractmethod
    def sound(self):
        pass  # Abstract method

    @abstractmethod
    def habitat(self):
        pass  # Abstract method

# Implementing the interface in subclasses
class Dog(Animal):
    def sound(self):
        return "Bark"  # Implementation of sound method

    def habitat(self):
        return "Domestic"  # Implementation of habitat method

class Cat(Animal):
    def sound(self):
        return "Meow"  # Implementation of sound method

    def habitat(self):
        return "Domestic"  # Implementation of habitat method

# Function to demonstrate polymorphism
def animal_info(animal: Animal):
    print(f"Animal sound: {animal.sound()}")
    print(f"Animal habitat: {animal.habitat()}")

# Creating instances of the subclasses
dog = Dog()
cat = Cat()

# Using the function with different animal types
animal_info(dog)
animal_info(cat)

Output:

Animal sound: Bark, Animal habitat: Domestic
Animal sound: Meow, Animal habitat: Domestic

When to Use Interfaces

Enforcing Method Implementation: Use interfaces when you want to ensure that certain methods are implemented in derived classes.
Designing Flexible APIs: Interfaces provide a way to define flexible APIs that can be easily extended or modified without changing existing code.
Promoting Polymorphism: Interfaces allow different classes to be treated the same way if they implement the same methods, promoting polymorphism.

Difference Between Abstract Classes and Interfaces

Feature	Abstract Classes	Interfaces
Implementation	Can have both implemented and unimplemented methods	Only unimplemented methods are defined
Multiple Inheritance	Can inherit from multiple abstract classes	Can inherit from multiple interfaces
State	Can have state (attributes)	Cannot maintain state
Constructor	Can have a constructor	Cannot have a constructor

Conclusion

Abstract classes and interfaces are essential for achieving polymorphism and designing flexible applications in Python. They help define clear contracts for classes and promote code reuse and maintainability.