Zasada odwrócenia zależności

Szybka definicja

Ostatnią zasadą wynikającą ze akronimu SOLID jest tytułowa zasada odwrócenia zależności (Dependency Inversion Principle). Zasada ta brzmi:

Żeby szybko zrozumieć o co tutaj chodzi posłużmy się przykładem.

Krótki przykład

Stworzymy nasz moduł wysokiego poziomu, którym będzie klasa Computer. Komputery z których korzystamy na co dzień posiadają jakieś urządzenia wskazujące. Mogą to być myszki, touchpady i zapewne jeszcze parę innych się znajdzie. Ich celem jest sterowanie pracą komputera więc w uproszczeniu nasze klasy będą wyglądały nastepująco:

public class Computer {
    private Mouse mouse;

    public Computer(Mouse mouse) {
        this.mouse = mouse;
    }

    public void enterTheFolder(){
        mouse.makeDoubleClick();
    }
}

public class Mouse {
    void makeDoubleClick() {
        //do something
    }
}

Zauważmy, że w powyższym przykładzie nasza klasa Computer będąca modułem wysokiego poziomu zależy od klasy Mouse będącej modułem niskiego poziomu. Aby uniknąć tej zależności wprowadzimy interfejs Pointer, którego właścicielem będzie klasa Computer. Wówczas kod będzie wyglądał tak:

public class Computer {
    private Pointer pointer;

    public Computer(Pointer mouse) {
        this.pointer = mouse;
    }

    public void enterTheFolder() {
        pointer.makeDoubleClick();
    }
}

public interface Pointer {
    public void makeDoubleClick();
}

public class Mouse implements Pointer {
    @Override
    public void makeDoubleClick() {
        //do something
    }
}

I takim oto sposobem nasz moduł wysokiego poziomu nie jest już zależny od modułu niskiego poziomu. Teraz możemy stworzyć nową klasę, która implementuje interfejs Pointer i bez problemu przekazać ją w konstruktorze klasy Computer.

Jeśli jeszcze nie zajrzałeś/aś do moich innych wpisów o zasadach SOLID to kliknij tutaj.