SOLID /

5. Zasada odwrócenia zależności

Zasada odwrócenia zależności (Dependency Inversion Principle, DIP)

Zasada ta mówi, że moduły wysokopoziomowe nie powinny zależeć od modułów niskopoziomowych, ale obie grupy powinny zależeć od abstrakcji.
Ponadto, abstrakcje nie powinny zależeć od szczegółów, ale szczegóły powinny zależeć od abstrakcji.

Poniżej znajdziesz przykład zasady DIP w języku Java. Załóżmy, że mamy klasę LightBulb i klasę Switch, gdzie Switch jest uzależniony bezpośrednio od LightBulb.
Java
// Klasa łamiąca zasadę DIP
class LightBulb {
    public void turnOn() {
        System.out.println("LightBulb: turned on");
    }

    public void turnOff() {
        System.out.println("LightBulb: turned off");
    }
}

class Switch {
    private LightBulb bulb;

    public Switch(LightBulb bulb) {
        this.bulb = bulb;
    }

    public void operate() {
        if (bulb != null) {
            if (!bulb.isOn()) {
                bulb.turnOn();
            } else {
                bulb.turnOff();
            }
        }
    }
}

public class Main {
    public static void main(String[] args) {
        // Użycie klasy łamiącej zasadę DIP
        LightBulb bulb = new LightBulb();
        Switch lightSwitch = new Switch(bulb);
        lightSwitch.operate();
    }
}

W powyższym przykładzie Switch jest bezpośrednio zależny od konkretnej implementacji LightBulb.

To narusza zasadę odwrócenia zależności.

Aby poprawić to naruszenie zasady DIP, możemy użyć interfejsu, aby stworzyć abstrakcję dla urządzeń, a następnie uzależnić Switch od tej abstrakcji:

Java
// Poprawione zastosowanie zasady DIP
interface Switchable {
    void turnOn();
    void turnOff();
    boolean isOn();
}

class LightBulb implements Switchable {
    private boolean on = false;

    @Override
    public void turnOn() {
        System.out.println("LightBulb: turned on");
        on = true;
    }

    @Override
    public void turnOff() {
        System.out.println("LightBulb: turned off");
        on = false;
    }

    @Override
    public boolean isOn() {
        return on;
    }
}

class Switch {
    private Switchable device;

    public Switch(Switchable device) {
        this.device = device;
    }

    public void operate() {
        if (device != null) {
            if (!device.isOn()) {
                device.turnOn();
            } else {
                device.turnOff();
            }
        }
    }
}

public class Main {
    public static void main(String[] args) {
        // Użycie poprawionego zastosowania zasady DIP
        Switchable bulb = new LightBulb();
        Switch lightSwitch = new Switch(bulb);
        lightSwitch.operate();
    }
}

W tym poprawionym przykładzie Switch korzysta teraz z interfejsu Switchable zamiast bezpośrednio zależnie od LightBulb. To spełnia zasadę odwrócenia zależności.

Scroll to Top