The Interface Segregation Principle (ISP) states that no client should be forced to depend on methods it does not use.

In simpler terms, ISP suggests that instead of having a large interface that all clients must implement, it is better to have several small and specific interfaces for each client.

# Segregation and Dependency?

• Segregation: Dividing large interfaces into smaller and more specific ones.
• Dependency: Clients should only know the parts they actually need and use.

The Interface Segregation Principle aims to reduce unnecessary dependencies between clients and abstractions, leading to more decoupled systems that are easier to refactor, change, and deploy.

# Why is it important?

# Symptoms of violation

We can identify when we are not respecting the Interface Segregation Principle:

• Classes that implement interfaces but only use some of the provided methods.
• Changes in an interface affecting clients that do not use the modified methods.
• Difficulty understanding which methods of an interface are actually relevant for a specific client.

Example

Imagine a system to manage workers in a company.

public interface Worker {
    void work();
    void eat();
    void takeBreak();
    // ... other methods
    }

public interface Workable {
    void work();
    }
public interface Eatable {
    void eat();
    }
public interface Breakable {
    void takeBreak();
    }