Chapter 20 - Interfaces

Interfaces are a core concept in programming, providing a blueprint for how objects, modules, or systems interact with one another. They define a contract that must be fulfilled by any class or struct implementing them. By separating the "what" from the "how," interfaces allow developers to write flexible, modular, and maintainable code. In this article, we'll explore interfaces, their purpose, different types, and how to use them effectively in Python, PHP, Go, C++, and Zig.

What Are Interfaces?

An interface is an abstract type that defines a set of methods that a class or object must implement. Unlike classes, interfaces do not contain any implementation details—they only specify method names, return types, and parameters. This abstraction is useful for achieving loose coupling in software design, enabling different parts of a system to work together without tightly depending on each other's implementations.

Types of Interfaces in Programming

Explicit Interfaces: Found in languages like Java, PHP, and Go, where you define interfaces explicitly using specific syntax (e.g., the interface keyword). These interfaces must be implemented by classes or structs.
Implicit Interfaces: Common in Go, where any type that satisfies the methods defined in an interface is said to "implement" it automatically.
Mixin Interfaces: Interfaces that provide default implementations for some methods, like in Python’s abstract base classes (ABCs) or traits in some languages.
Functional Interfaces: Typically used in functional programming paradigms, these interfaces define a single method and are used for callbacks or functional operations.

Why Interfaces Are Important

Interfaces play a critical role in software development for several reasons:

Encapsulation: They separate implementation details from usage.
Polymorphism: Interfaces allow for treating different objects uniformly if they implement the same interface.
Testability: Mock implementations of interfaces make unit testing easier.
Reusability: Code can be reused across different modules if it adheres to a common interface.

Declaring and Using Interfaces in Python

Python uses abstract base classes (ABCs) from the abc module to define interfaces. Here’s an example:

from abc import ABC, abstractmethod

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

    @abstractmethod
    def stop_engine(self):
        pass

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

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

# Usage
vehicle = Car()
vehicle.start_engine()
vehicle.stop_engine()

In this example, the Vehicle abstract base class serves as the interface, defining two methods that any subclass must implement.

Defining Interfaces in PHP

PHP offers an explicit syntax for interfaces using the interface keyword:

<?php
interface Vehicle {
    public function startEngine();
    public function stopEngine();
}

class Car implements Vehicle {
    public function startEngine() {
        echo "Car engine started.\n";
    }

    public function stopEngine() {
        echo "Car engine stopped.\n";
    }
}

// Usage
$vehicle = new Car();
$vehicle->startEngine();
$vehicle->stopEngine();
?>

Here, the Vehicle interface defines two methods that must be implemented by any class that implements it.

Leveraging Interfaces in Go

Go uses implicit interfaces, where any type that implements the methods of an interface satisfies that interface:

package main

import "fmt"

type Vehicle interface {
    StartEngine()
    StopEngine()
}

type Car struct{}

func (c Car) StartEngine() {
    fmt.Println("Car engine started.")
}

func (c Car) StopEngine() {
    fmt.Println("Car engine stopped.")
}

func main() {
    var vehicle Vehicle = Car{}
    vehicle.StartEngine()
    vehicle.StopEngine()
}

In this example, the Vehicle interface is satisfied by the Car type because it implements the required methods.

Creating and Implementing Interfaces in C++

In C++, interfaces are typically represented by abstract classes with pure virtual functions:

#include <iostream>
using namespace std;

class Vehicle {
public:
    virtual void startEngine() = 0;
    virtual void stopEngine() = 0;
    virtual ~Vehicle() = default;
};

class Car : public Vehicle {
public:
    void startEngine() override {
        cout << "Car engine started." << endl;
    }

    void stopEngine() override {
        cout << "Car engine stopped." << endl;
    }
};

int main() {
    Vehicle* vehicle = new Car();
    vehicle->startEngine();
    vehicle->stopEngine();
    delete vehicle;
    return 0;
}

The Vehicle class acts as an interface, and Car implements it by overriding the pure virtual functions.

Working with Interfaces in Zig

Zig doesn’t have native support for interfaces, but similar functionality can be achieved using structs and function pointers:

const std = @import("std");

const Vehicle = struct {
    startEngine: fn (),
    stopEngine: fn (),
};

const Car = struct {};

fn startCarEngine() void {
    std.debug.print("Car engine started.\n", .{});
}

fn stopCarEngine() void {
    std.debug.print("Car engine stopped.\n", .{});
}

pub fn main() void {
    const car = Vehicle{
        .startEngine = startCarEngine,
        .stopEngine = stopCarEngine,
    };
    car.startEngine();
    car.stopEngine();
}

In Zig, we simulate interfaces using structs with function pointers.

Comparing Interfaces Across Languages

Language	Interface Type	Syntax/Approach
Python	Explicit	Abstract base classes (`abc` module)
PHP	Explicit	`interface` keyword
Go	Implicit	Method matching
C++	Explicit	Abstract classes with virtual methods
Zig	Simulated	Structs with function pointers

Practical Use Cases of Interfaces

Dependency Injection: Define interfaces for services and inject different implementations depending on the context.
Polymorphism: Use interfaces to treat different classes uniformly, e.g., handling various types of vehicles under a common interface.
Plugins and Extensions: Design systems where plugins adhere to a shared interface, allowing for easy extensibility.

Conclusion

Interfaces are a powerful tool for designing robust and scalable systems. They define contracts that improve code quality, promote reuse, and enable polymorphism. By understanding how to use interfaces effectively in different programming languages, developers can write cleaner and more maintainable code.

Last modified: 26 January 2025