Interface Segregation Principle

Also Known As

TL;DR

Explanation

The I in SOLID, ISP states that a class implementing an interface should not be forced to implement methods it doesn't use. Fat interfaces that bundle unrelated methods force implementors to provide stub implementations for irrelevant methods. The solution is to split large interfaces into smaller, cohesive ones and have classes implement only what they need. This complements the Dependency Inversion Principle — depend on the narrowest interface needed for the task.

Common Misconception

Why It Matters

Common Mistakes

• One large repository interface with 20 methods — every implementation must stub 15 unused ones.
• Adding new methods to an existing interface instead of extending it — breaks all implementors.
• Not splitting interfaces at natural capability boundaries — Readable, Writable, Listable rather than FileRepository.
• Confusing ISP with SRP — ISP is about interface design, SRP is about class responsibility.

Code Examples

interface Worker {
    public function work(): void;
    public function eat(): void;   // robots don't eat!
    public function sleep(): void; // robots don't sleep!
}

class RobotWorker implements Worker {
    public function eat(): void  { throw new \Exception('Robots do not eat'); }
    public function sleep(): void { throw new \Exception('Robots do not sleep'); }
}

interface Workable  { public function work(): void; }
interface Feedable  { public function eat(): void; }
interface Restable  { public function sleep(): void; }

class HumanWorker  implements Workable, Feedable, Restable { ... }
class RobotWorker  implements Workable { ... }

References

• ↗ https://en.wikipedia.org/wiki/Interface_segregation_principle

Tags

Related Terms