Interface Segregation Principle (ISP)

SOLID Principles of Object-Oriented Design (Study Notes)

Interface Segregation Principle (ISP)

“Clients should not be forced to depend on methods they do not use.” In essence, large interfaces should be broken into smaller, role-specific interfaces so that implementing classes only need to know about the methods that matter to them.

Purpose:

• Avoids “fat” interfaces – by splitting broad interfaces into focused ones, no class is burdened with irrelevant methods.
• Reduces coupling and side effects: Changes to one part of an interface won’t impact classes that don’t use that part.
• Makes implementations simpler and more flexible. A class can implement multiple small interfaces as needed, rather than one monolithic interface.

Minimal Example

Imagine a multi-function printer interface that includes printing, scanning, and faxing in one. A simple printer that only prints would still be forced to implement (or stub out) scan() and fax() methods, which it doesn’t need – violating ISP. Below, MultiFunctionDevice represents such a bloated interface and OldPrinter is needlessly forced to depend on unused methods. The solution is to segregate the interfaces: separate Printer, Scanner, and Fax interfaces so that classes implement only what they actually support.

# Big interface (violates ISP):
class MultiFunctionDevice:
    def print(self, doc): raise NotImplementedError
    def scan(self, doc): raise NotImplementedError
    def fax(self, doc):  raise NotImplementedError

class OldPrinter(MultiFunctionDevice):
    def print(self, doc):
        print("Printing:", doc)
    def scan(self, doc):
        pass  # Not supported, but must implement
    def fax(self, doc):
        pass  # Not supported, but must implement

# Interface segregation: smaller, specific interfaces
class Printer:
    def print(self, doc): raise NotImplementedError

class Scanner:
    def scan(self, doc): raise NotImplementedError

class Fax:
    def fax(self, doc): raise NotImplementedError

class SimplePrinter(Printer):
    def print(self, doc):
        print("Printing:", doc)
# SimplePrinter only implements Printer, no need for scan/fax methods.

More Realistic Example

Building on the printing example, we can have distinct interfaces and classes for each capability. For instance, PhotoPrinter implements Printer, OfficeScanner implements Scanner. A multi-function machine can be composed by combining a printer and a scanner implementation without any class having to implement methods it doesn’t use. This demonstrates how ISP enables flexible combinations of behaviors:

class PhotoPrinter(Printer):
    def print(self, doc):
        print("Printing photo:", doc)

class OfficeScanner(Scanner):
    def scan(self, doc):
        print("Scanning document:", doc)

class MultiFunctionMachine(Printer, Scanner):
    def __init__(self, printer: Printer, scanner: Scanner):
        self.printer = printer
        self.scanner = scanner
    def print(self, doc):
        # Delegate to an internal Printer
        self.printer.print(doc)
    def scan(self, doc):
        # Delegate to an internal Scanner
        self.scanner.scan(doc)

# Using the segregated interfaces:
printer = PhotoPrinter()
scanner = OfficeScanner()
mfp = MultiFunctionMachine(printer, scanner)  # compose a multi-function device

mfp.print("image.png")   # Output: Printing photo: image.png
mfp.scan("file.txt")     # Output: Scanning document: file.txt

# We could easily swap in different implementations for each interface as needed.