SOLID /

4. Zasada segregacji interfejsów

Zasada segregacji interfejsów (Interface Segregation Principle, ISP).

Mówi ona, że klient nie powinien być zmuszany do implementacji interfejsów, których nie używa.
Zamiast tego, lepiej jest tworzyć małe, specjalizowane interfejsy, które są dostosowane do konkretnych potrzeb klienta.

Poniżej znajdziesz przykład zasady ISP. Załóżmy, że mamy interfejs Worker, który zawiera metody związane zarówno z pracą biurową, jak i z pracą na produkcji.
Java
// Klasa łamiąca zasadę ISP
interface Worker {
    void doOfficeWork();
    void doProductionWork();
}

class OfficeWorker implements Worker {
    @Override
    public void doOfficeWork() {
        // logika związana z pracą biurową
        System.out.println("Doing office work");
    }

    @Override
    public void doProductionWork() {
        // logika związana z pracą na produkcji
        System.out.println("Doing production work");
    }
}

class FactoryWorker implements Worker {
    @Override
    public void doOfficeWork() {
        // logika związana z pracą biurową
        System.out.println("Doing office work");
    }

    @Override
    public void doProductionWork() {
        // logika związana z pracą na produkcji
        System.out.println("Doing production work");
    }
}

public class Main {
    public static void main(String[] args) {
        // Użycie klasy łamiącej zasadę ISP
        Worker officeWorker = new OfficeWorker();
        officeWorker.doOfficeWork();
        officeWorker.doProductionWork();

        Worker factoryWorker = new FactoryWorker();
        factoryWorker.doOfficeWork();
        factoryWorker.doProductionWork();
    }
}

W powyższym przykładzie obie klasy, OfficeWorker i FactoryWorker, muszą implementować obie metody interfejsu Worker, chociaż każda z nich używa tylko jednej z tych metod. To łamie zasadę segregacji interfejsów.

Aby naprawić naruszenie zasady ISP, możemy stworzyć osobne interfejsy dla pracowników biurowych i pracowników na produkcji:

Java
// Poprawione zastosowanie zasady ISP
interface OfficeWorker {
    void doOfficeWork();
}

interface FactoryWorker {
    void doProductionWork();
}

class OfficeWorkerImpl implements OfficeWorker {
    @Override
    public void doOfficeWork() {
        // logika związana z pracą biurową
        System.out.println("Doing office work");
    }
}

class FactoryWorkerImpl implements FactoryWorker {
    @Override
    public void doProductionWork() {
        // logika związana z pracą na produkcji
        System.out.println("Doing production work");
    }
}

public class Main {
    public static void main(String[] args) {
        // Użycie poprawionego zastosowania zasady ISP
        OfficeWorker officeWorker = new OfficeWorkerImpl();
        officeWorker.doOfficeWork();

        FactoryWorker factoryWorker = new FactoryWorkerImpl();
        factoryWorker.doProductionWork();
    }
}

W tym przypadku mamy osobne interfejsy OfficeWorker i FactoryWorker, które są implementowane przez odpowiednie klasy.

To spełnia zasadę segregacji interfejsów, ponieważ klient nie jest zmuszany do implementacji metod, których nie używa.

Scroll to Top