依赖倒置原则（Dependency Inversion Principle）

依赖倒置原则（Dependency Inversion Principle，简称DIP）是面向对象设计中的一个原则，它强调高层模块不应该依赖于底层模块，二者都应该依赖于抽象；而抽象不应该依赖于细节，细节应该依赖于抽象。简而言之，依赖倒置原则要求通过抽象（接口或抽象类）来实现模块之间的松耦合。

反例：

class LightBulb {
    public void turnOn() {
        // 点亮灯泡的逻辑
    }

    public void turnOff() {
        // 关闭灯泡的逻辑
    }
}

class Switch {
    private LightBulb bulb;

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

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

在上面的例子中，Switch 类直接依赖于具体的 LightBulb 类。这违反了依赖倒置原则，因为高层模块 Switch 依赖于底层模块 LightBulb，而且具体的细节已经硬编码在高层模块中。

正例：

interface Switchable {
    void turnOn();

    void turnOff();
}

class LightBulb implements Switchable {
    @Override
    public void turnOn() {
        // 点亮灯泡的逻辑
    }

    @Override
    public void turnOff() {
        // 关闭灯泡的逻辑
    }
}

class Fan implements Switchable {
    @Override
    public void turnOn() {
        // 打开风扇的逻辑
    }

    @Override
    public void turnOff() {
        // 关闭风扇的逻辑
    }
}

class Switch {
    private Switchable device;

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

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

在正例中，Switch 类依赖于抽象的 Switchable 接口，而不是具体的细节。LightBulb 和 Fan 类都实现了 Switchable 接口，这样 Switch 类不再依赖于具体的实现，而是依赖于抽象的接口。这符合依赖倒置原则，高层模块和底层模块都依赖于抽象，降低了耦合度，提高了系统的灵活性和可维护性。