设计模式原则 - 依赖倒转(Dependency Inversi

个人理解 ，随手写下的笔记。不足之处，请谅解。

定义

1. 高层模块不应该依赖底层模块，都应该依赖于抽象^[1]。
2. 抽象不应该依赖于具体^[2]，具体依赖于抽象。

问题的由来

类A直接依赖类B，假如要将类A改为依赖类C，则必须通过修改类A的代码来达成。这种场景下，类A一般是高层模块，负责复杂的业务逻辑；类B和类C是低层模块，负责基本的原子操作；假如修改类A，会给程序带来不必要的风险。

依赖倒置有三种方式来实现

1. 通过构造函数传递依赖对象； 比如在构造函数中的需要传递的参数是抽象类或接口的方式实现。
2. 通过setter方法传递依赖对象； 即在我们设置的setXXX方法中的参数为抽象类或接口，来实现传递依赖对象。
3. 接口声明实现依赖对象，也叫接口注入；即在函数声明中参数为抽象类或接口，来实现传递依赖对象，从而达到直接使用依赖对象的目的。

Java例子

1 很多地方引用的个人觉得也非常有代表性的一个例子:公司是福特和本田公司的金牌合作伙伴，现要求开发一套自动驾驶系统，只要汽车上安装该系统就可以实现无人驾驶，该系统可以在福特和本田车上使用，只要这两个品牌的汽车使用该系统就能实现自动驾驶。

/**
 * 汽车接口
 */
public interface ICar {
    void run();
    void stop();
}

/**
 * 自动驾驶系统
 */
public class AutoCarSystem {
    //通过接口编程不和具体实现累有关系，只要每个车符合驾驶系统定义的功能就行了
    private ICar car = null;
    public AutoCarSystem(ICar car) {
        this.car = car;
    }
    public void setCar(ICar car) {
        this.car = car;
    }
    public void carRun() {
        car.run();
    }
    public void carStop() {
        car.stop();
    }
}
/**
 * Fute汽车实现驾驶系统的操作
 */
public class FuteCar implements ICar {
    @Override
    public void run() {
        System.out.println("FuteCar run");
    }
    @Override
    public void stop() {
        System.out.println("FuteCar stop");
    }
}
/**
 * Benz汽车实现驾驶系统的操作
 */
public class BenzCar implements ICar {
    @Override
    public void run() {
        System.out.println("BenzCar run");
    }
    @Override
    public void stop() {
        System.out.println("BenzCar stop");
    }
}

调用Demo

public class TestDemo {
    public static void main(String[] args) {
        FuteCar futeCar = new FuteCar();
        BenzCar benzCar = new BenzCar();
        //实例化一个自动车载系统，安装了不同的车上
        //安装了futeCar
        AutoCarSystem autoCarSystem = new AutoCarSystem(futeCar);
        autoCarSystem.carRun();
        autoCarSystem.carStop();    
        //安装benzCar
        autoCarSystem.setCar(benzCar);
        autoCarSystem.carRun();
        autoCarSystem.carStop();
        //如果想给奥迪也这个自动驾驶系统也想用到奥迪车上，就通过ICar实现一个奥迪车的类，然后直接按上自动驾驶系统就好了，就不需要改自动驾驶系统就能操作奥迪车了。可以动手试试，体会体会。
    }
}

控制端输出结果

FuteCar run
FuteCar stop
BenzCar run
BenzCar stop

2.再来个例子，人看书，一个人可以看很多书

/**
 * 书的内容
 */
public interface IBook {
    //书的标题
    String title();
    //书的内容
    String content();
}
/**
 * 人读书
 * 读什么书还不知道，只知道在读书的标题和内容
 */
public class PeopleReadBook {
    private IBook book = null;
    public PeopleReadBook(IBook book) {
        this.book = book;
    }
    public void setBook(IBook book) {
        this.book = book;
    }
    public void readTitle() {
        System.out.println("书名:" + book.title());
    }
    public void readContent() {
        System.out.println("内容:" + book.content());
    }
}
/**
 * Java书实现了书的内容
 */
public class JavaBook implements IBook {
    @Override
    public String title() {
        return "Java 入门到精通";
    }
    @Override
    public String content() {
        return "学习Java，精通到放弃";
    }
}
/**
 * C书实现了书的内容
 */
public class CBook implements IBook {
    @Override
    public String title() {
        return "C 入门到精通";
    }
    @Override
    public String content() {
        return "学习C，精通到放弃";
    }
}

调用Demo

public class TestDemo {
    public static void main(String[] args) {
        JavaBook javaBook = new JavaBook();
        CBook cBook = new CBook();
        
        PeopleReadBook peopleReadBook = new PeopleReadBook(javaBook);
        peopleReadBook.readTitle();
        peopleReadBook.readContent();
        
        peopleReadBook.setBook(cBook);
        peopleReadBook.readTitle();
        peopleReadBook.readContent();
    }
}

控制端输出结果

书名:Java 入门到精通
内容:学习Java，精通到放弃
书名:C 入门到精通
内容:学习C，精通到放弃

参考

JAVA设计原则之依赖倒置原则
设计模式六大原则（3）：依赖倒置原则
设计原则（四）依赖倒置原则（DIP）
设计模式6大原则：依赖倒置原则

---

1. 在Java中抽象一般就是指Java接口(interface)或者抽象类(abstract class)。 ↩

2. 在Java中具体或者细节一般指的是实现类。 ↩