Najważniejsze zasady programowania: SOLID, DRY i inne

Zasada Segregacji Interfejsów (Interface Segregation Principle)

Co to jest zasada Interface Segregation Principle?

Zasada Segregacji Interfejsów (Interface Segregation Principle, ISP) mówi, że interfejsy powinny być wąsko wyspecjalizowane, aby uniknąć sytuacji, w której klasy są zmuszane do implementowania metod, których nie używają. Kluczowym celem tej zasady jest zapobieganie tworzeniu tzw. „grubych interfejsów”, które wymuszają na klasach niepotrzebne zależności.

Dlaczego zasada Interface Segregation Principle jest ważna?

Stosowanie zasady ISP sprawia, że kod jest bardziej elastyczny i łatwiejszy do utrzymania. Dzięki niej klasy mają tylko te metody, które rzeczywiście są im potrzebne, co zwiększa czytelność kodu i ułatwia jego refaktoryzację. W kontekście programowania obiektowego zasada ISP pomaga uniknąć tzw. „przeciążenia interfejsów”, które prowadzi do trudności w utrzymaniu i rozwijaniu kodu.

Przykład łamania zasady ISP

Załóżmy, że mamy interfejs Workable, który posiada dwie metody: code() oraz test(). Obie te metody muszą być zaimplementowane przez każdą klasę, która implementuje interfejs Workable:

// Interfejs wymuszający implementację obu metod
class Workable {
    code() {
        throw new Error("Metoda 'code()' musi być zaimplementowana!");
    }
    test() {
        throw new Error("Metoda 'test()' musi być zaimplementowana!");
    }
}

// Klasa Developer implementuje obie metody
class Developer extends Workable {
    code() {
        console.log("Developer koduje");
    }
    test() {
        console.log("Developer testuje kod");
    }
}

// Klasa Tester implementuje obie metody, ale testuje tylko
class Tester extends Workable {
    code() {
        throw new Error("Tester nie koduje!");
    }
    test() {
        console.log("Tester testuje kod");
    }
}

const dev = new Developer();
dev.code(); // Developer koduje
dev.test(); // Developer testuje kod

const tester = new Tester();
tester.code(); // Błąd: Tester nie koduje!
tester.test(); // Tester testuje kod

W powyższym przykładzie Tester jest zmuszony do implementacji metody code(), mimo że jej nie używa. To prowadzi do łamania zasady Interface Segregation Principle.

Jak poprawić kod zgodnie z zasadą ISP?

Aby poprawić kod, należy rozdzielić „gruby” interfejs na mniejsze, bardziej wyspecjalizowane interfejsy. W naszym przypadku możemy stworzyć dwa interfejsy: Codable oraz Testable.

// Interfejs do kodowania
class Codable {
    code() {
        throw new Error("Metoda 'code()' musi być zaimplementowana!");
    }
}

// Interfejs do testowania
class Testable {
    test() {
        throw new Error("Metoda 'test()' musi być zaimplementowana!");
    }
}

// Klasa Developer implementuje tylko interfejs Codable
class Developer extends Codable {
    code() {
        console.log("Developer koduje");
    }
}

// Klasa Tester implementuje tylko interfejs Testable
class Tester extends Testable {
    test() {
        console.log("Tester testuje kod");
    }
}

const dev = new Developer();
dev.code(); // Developer koduje

const tester = new Tester();
tester.test(); // Tester testuje kod

Teraz każda klasa implementuje tylko te interfejsy, które są jej potrzebne, co jest zgodne z zasadą ISP.

Korzyści ze stosowania zasady Interface Segregation Principle

• Zmniejszenie zależności: Klasy implementują tylko te interfejsy, które są im faktycznie potrzebne, co minimalizuje zależności między komponentami.

• Lepsza czytelność: Klasy są mniej skomplikowane, ponieważ implementują tylko niezbędne metody.

• Łatwiejsza refaktoryzacja: Modyfikacja jednego interfejsu nie wpływa na wszystkie klasy, które go implementują, co zmniejsza ryzyko wystąpienia błędów.