对“依赖倒置原则”的理解

设计模式原则-依赖倒置原则

一句话说就是：上层模块应该依赖抽象，而不应该依赖具体的实现；抽象不应该依赖细节；细节应该依赖抽象。

上层的意思就是依赖方，例如一个人出远门需要依赖交通工具，下层就是被依赖方，如交通工具。交通工具包括大巴、火车、飞机、高铁等。

反例：按照下面UML图，我们将实现代码写出来；

---

class Car {
    public void drive() {
        System.out.println("汽车...");
    }
}

class Train {
    public void drive() {
        System.out.println("火车...");
    }
}

class Plane {
    public void drive() {
        System.out.println("飞机...");
    }
}

public class Person {
    public void ride(Car car) {
        car.drive();
    }

    public void ride(Train car) {
        car.drive();
    }

    public void ride(Plane car) {
        car.drive();
    }


    public static void main(String[] args) {
        Person person = new Person();
        person.ride(new Car());
        person.ride(new Train());
        person.ride(new Plane());
    }
}

可以看到每个种类的交通工具都需要去重载一个方法才能执行，要是有100种交通出行方式，则需要写100个重载，这是非常臃肿的，下面我们使用依赖倒置原则看看正例如何解决。

 

正例：按照下面正例的UML图，我们将实现代码写出来；

---

/**
 * 定义抽象
 */
interface Vehicle {
    void drive();
}

class Car implements Vehicle {
    @Override
    public void drive() {
        System.out.println("汽车...");
    }
}

class Train implements Vehicle {
    @Override
    public void drive() {
        System.out.println("火车...");
    }
}

class Plane implements Vehicle {
    @Override
    public void drive() {
        System.out.println("飞机...");
    }
}

public class Person {
    /**
     * 去掉多余重载用统一接口接收参数
     * @param vehicle
     */
    public void ride(Vehicle vehicle) {
        vehicle.drive();
    }


    public static void main(String[] args) {
        Person person = new Person();
        person.ride(new Car());
        person.ride(new Train());
        person.ride(new Plane());
    }
}

可以看到原本上层依赖的箭头是向下依赖的，而加了统一抽象后，上层依赖了抽象，实现的箭头则“倒置”了；我们即使如何扩展交通工具也不需要改变客户端的调用，只需要实现统一的抽象即可，这样就实现了客户端的解耦。