Abstract Classes and Interfaces

In your journey with Object-Oriented Programming (OOP), you’ll soon realize that just polymorphism isn’t always enough. Sometimes, you want to enforce a specific structure or contract in your code — meaning that certain classes must implement some methods.

That’s where Abstract Classes and Interfaces come into play. They help you design robust and maintainable systems by defining blueprints for other classes to follow.

What Are Abstract Classes? #

An Abstract Class is a class that cannot be instantiated directly but serves as a base for other classes. It can contain:

• Abstract methods (methods without implementation)
• Concrete methods (methods with implementation)

Abstract classes set a contract:
Any subclass must implement all abstract methods, or it won’t be instantiable.

Why use abstract classes? #

• To define a common interface (set of methods) that all subclasses should follow.
• To provide some default behavior but force subclasses to customize key parts.
• To avoid accidental instantiation of base classes that are meant only for inheritance.

Abstract Classes in Python with abc Module #

Python supports abstract classes via the abc module (Abstract Base Classes).

How to define an abstract class? #

• Import ABC and abstractmethod decorators from abc.
• Inherit from ABC.
• Use @abstractmethod to mark methods that must be implemented in subclasses.

Example: #

from abc import ABC, abstractmethod

class Vehicle(ABC):
    @abstractmethod
    def start_engine(self):
        pass

    @abstractmethod
    def stop_engine(self):
        pass

    def honk(self):
        print("Beep beep!")

# Trying to instantiate Vehicle will raise an error:
# vehicle = Vehicle()  # TypeError: Can't instantiate abstract class Vehicle with abstract methods...

class Car(Vehicle):
    def start_engine(self):
        print("Car engine started")

    def stop_engine(self):
        print("Car engine stopped")

car = Car()
car.start_engine()  # Car engine started
car.honk()          # Beep beep!
car.stop_engine()   # Car engine stopped

Important Notes: #

• If Car does not implement all abstract methods, it itself becomes abstract and cannot be instantiated.
• Abstract methods don’t need to be empty; you can provide some default behavior, but often they are left empty to force customization.

What Are Interfaces? (Python Perspective) #

Interfaces define a set of methods that a class must implement but do not provide any implementation themselves.

While Python doesn’t have a formal interface keyword (like Java or C#), you can create interfaces in Python using abstract base classes with only abstract methods.

In other languages, interfaces serve purely as contracts with no method bodies. In Python, abstract base classes with only abstract methods act like interfaces.

Creating an Interface-Like Abstract Class in Python #

from abc import ABC, abstractmethod

class PaymentGateway(ABC):
    @abstractmethod
    def process_payment(self, amount):
        pass

    @abstractmethod
    def refund_payment(self, amount):
        pass

class PayPalGateway(PaymentGateway):
    def process_payment(self, amount):
        print(f"Processing PayPal payment of ${amount}")

    def refund_payment(self, amount):
        print(f"Refunding PayPal payment of ${amount}")

class StripeGateway(PaymentGateway):
    def process_payment(self, amount):
        print(f"Processing Stripe payment of ${amount}")

    def refund_payment(self, amount):
        print(f"Refunding Stripe payment of ${amount}")

# Usage
paypal = PayPalGateway()
stripe = StripeGateway()

paypal.process_payment(100)
stripe.refund_payment(50)

Why Use Interfaces / Abstract Classes? #

1. Enforce consistency: All payment gateways must implement the same methods.
2. Enable polymorphism: You can handle all gateways interchangeably.
3. Clear design contracts: Developers know exactly what needs implementation.
4. Decouple code: You can change implementations without touching code that uses the interface.

Real-World Use Case 1: Plugin Architecture for a CMS (Content Management System) #

Imagine you’re building a CMS that supports plugins for different content formats (video, text, audio).

You want all plugins to:

• Load content
• Render content
• Save content

But the implementation differs widely.

Step 1: Define a Plugin Interface #

from abc import ABC, abstractmethod

class ContentPlugin(ABC):
    @abstractmethod
    def load(self, source):
        pass

    @abstractmethod
    def render(self):
        pass

    @abstractmethod
    def save(self, destination):
        pass

Step 2: Implement Plugins #

class VideoPlugin(ContentPlugin):
    def load(self, source):
        print(f"Loading video from {source}")

    def render(self):
        print("Rendering video content")

    def save(self, destination):
        print(f"Saving video to {destination}")

class TextPlugin(ContentPlugin):
    def load(self, source):
        print(f"Loading text from {source}")

    def render(self):
        print("Rendering text content")

    def save(self, destination):
        print(f"Saving text to {destination}")

Step 3: Using the Plugins #

def process_plugin(plugin: ContentPlugin, source, destination):
    plugin.load(source)
    plugin.render()
    plugin.save(destination)

video = VideoPlugin()
text = TextPlugin()

process_plugin(video, "video.mp4", "video_backup.mp4")
process_plugin(text, "document.txt", "document_backup.txt")

Benefits:
The CMS core code interacts only with the abstract interface. New plugins can be added with zero changes to core code.

Real-World Use Case 2: Payment Gateway Integration (Expanded) #

You are building an e-commerce app that supports multiple payment providers (PayPal, Stripe, Square).

• Each provider has different APIs but must support:
  • Authorizing payment
  • Capturing payment
  • Refunding payment

Interface Design #

from abc import ABC, abstractmethod

class PaymentProcessor(ABC):
    @abstractmethod
    def authorize(self, amount):
        pass

    @abstractmethod
    def capture(self, amount):
        pass

    @abstractmethod
    def refund(self, amount):
        pass

Implementations: #

class PayPalProcessor(PaymentProcessor):
    def authorize(self, amount):
        print(f"Authorizing ${amount} via PayPal")

    def capture(self, amount):
        print(f"Capturing ${amount} via PayPal")

    def refund(self, amount):
        print(f"Refunding ${amount} via PayPal")

class StripeProcessor(PaymentProcessor):
    def authorize(self, amount):
        print(f"Authorizing ${amount} via Stripe")

    def capture(self, amount):
        print(f"Capturing ${amount} via Stripe")

    def refund(self, amount):
        print(f"Refunding ${amount} via Stripe")

Application Layer #

def process_payment(processor: PaymentProcessor, amount):
    processor.authorize(amount)
    processor.capture(amount)

def process_refund(processor: PaymentProcessor, amount):
    processor.refund(amount)

paypal = PayPalProcessor()
stripe = StripeProcessor()

process_payment(paypal, 100)
process_refund(stripe, 50)

Result:
Your code is clean, flexible, and ready to accept new payment processors without touching business logic.

Abstract Classes with Concrete Methods #

Sometimes, you want an abstract class to provide some common functionality.

Example: Template Method Pattern #

from abc import ABC, abstractmethod

class DataParser(ABC):
    def parse(self, data):
        self.read(data)
        self.process()
        self.save()

    @abstractmethod
    def read(self, data):
        pass

    @abstractmethod
    def process(self):
        pass

    def save(self):
        print("Saving parsed data to database")

class CSVParser(DataParser):
    def read(self, data):
        print(f"Reading CSV data: {data}")

    def process(self):
        print("Processing CSV data")

csv_parser = CSVParser()
csv_parser.parse("name,age\nAlice,30")

This pattern is useful when you want a fixed process (like parse → process → save) but allow subclasses to customize parts of it.

Summary Table: Abstract Classes vs Interfaces in Python #

When to Use Abstract Classes or Interfaces? #

• Use abstract classes when:
  • You want to share some common code between subclasses.
  • You want to provide a default implementation for some methods.
  • You want to create a base class that should not be instantiated.
• Use interface-like abstract base classes when:
  • You only want to define method signatures.
  • You want to enforce that all subclasses implement specific methods.
  • You want maximum flexibility in implementations.

Practical Tips for Writing Abstract Classes #

• Keep abstract methods focused on core behaviors subclasses must implement.
• Provide helpful docstrings for abstract methods to guide subclass developers.
• Use concrete methods for shared utility functions.
• Use descriptive class names like Base, Abstract, or Interface suffixes for clarity.
• Use @abstractmethod with @classmethod or @staticmethod if needed.

Final Thoughts #

Abstract classes and interfaces help you design clean, flexible, and scalable OOP systems. They formalize your design intent and reduce bugs by enforcing consistent method implementation.

You’ve already seen how Python supports this powerful paradigm with the abc module, mixing both strict contracts and flexible implementations. Mastering these concepts will elevate your software design skills tremendously.