【设计模式】依赖倒转原则

依赖倒转原则

依赖倒转原则是指的特点有∶

1. 高层模块不应该依赖低层模块，二者都应该依赖其抽象
2. 抽象不应该依赖细节，细节应该依赖抽象
3. 依赖倒转（倒置）的 中心思想 是面向接口编程
4. 依赖倒转原则是基于这样的设计理念∶相对于细节的多变性，抽象的东西要稳定的多。以抽象为基础搭建的架
构比以细节为基础的架构要稳定的多。在 Java 中，抽象指的是接口或抽象类，细节就是具体的实现类
5. 使用接口或抽象类的目的是制定好规范，而不涉及任何具体的操作，把展现细节的任务交给他们的实现类去完
成

使用接口传递的方法体现依赖倒转原则

interface Received {
    public String getInfo();
}

class Email implements Received {

    public String getInfo() {
        return "使用Email接收。。";
    }
}

class Phone implements Received {

    public String getInfo() {
        return "使用手机接收、、";
    }
}

class Person {
    /**
     * 对接口的依赖
     */
    public void received(Received receive) {
        System.out.println(receive.getInfo());
    }
}

public class DependencyInversion {
    public static void main(String[] args) {
        // 使用接口传递
        Person person = new Person();
        person.received(new Email());
        person.received(new Phone());
    }
}

使用构造方法传递的方法体现依赖倒转原则

interface Received {
    public String getInfo();
}

class Email implements Received {
    public String getInfo() {
        return "使用Email接收。。";
    }
}

class Phone implements Received {

    public String getInfo() {
        return "使用手机接收、、";
    }
}
/**
* 接收实体（调用实体）
*/
class Person {
    // 在调用者类中设立构造器
    public Received receive;
    public Person(Received receive) {
        this.receive = receive;
    }
    public void received() {
        System.out.println(receive.getInfo());
    }
}

public class DependencyInversion {
    public static void main(String[] args) {
        // 构造器传递
        Person person1 = new Person(new Email());
        person1.received();
        // 构造器传递
        Person person2 = new Person(new Phone());
        person2.received();
    }
}

使用 setter() 方法传递的方法体现依赖倒转原则（只需要将利用构造器方法传递中的“接收实体”中的以接口为参数的构造器改为setter()方法，使用的使用利用setter()方法传入接口对象即可）

interface Received {
    public String getInfo();
}

class Email implements Received {
    public String getInfo() {
        return "使用Email接收。。";
    }
}

class Phone implements Received {

    public String getInfo() {
        return "使用手机接收、、";
    }
}
/**
* 接收实体（调用实体）
*/
class Person {
    public Received receive;

    public void setReceive(Received receive) {
        this.receive = receive;
    }

    public void received() {
        System.out.println(receive.getInfo());
    }
}

public class DependencyInversion {
    public static void main(String[] args) {
        // setter()方法传递
        Person person = new Person();
        person.setReceive(new Email());
        person.received();
    }
}

加入有一个【对象obj】，若【obj】直接指向一个对象，而没有经过一个中间的 缓冲区，那么随着系统的扩展，如果需要对指向的对象进行功能的扩展难度较大（修改数据、方法等等或许会影响到引用它的obj是否满足原来需求）。

比如，这里有一个【抽象类A】，它的实现类是B，那我们在操作的时候可以用 A obj = new B(); —— 这样做的好处是，如果之后要扩展功能，我们不需要直接扩展B（因为B可能也被其他对象所依赖引用），而可以在A中修改代码，可以对子类B中的方法做一个优化处理。

在继承时，需要遵循【里氏替换原则】