04.接口隔离原则 (ISP)

ISP全称

ISP, Interface Segregation Principles 接口隔离原则

定义

一个类对另一个类的依赖应该建立在最小的接口上

接口隔离原则和单一职责区别

接口隔离原则和单一职责都是为了提高类的内聚性、降低它们之间的耦合性，体现了封装的思想，但两者是不同的：
1. 单一职责原则注重的是职责，而接口隔离原则注重的是对接口依赖的隔离。
2. 单一职责原则主要是约束类，它针对的是程序中的实现和细节；接口隔离原则主要约束接口，主要针对抽象和程序整体框架的构建。

优点

将臃肿庞大的接口分解为多个粒度小的接口，可以预防外来变更的扩散，提高系统的灵活性和可维护性。
接口隔离提高了系统的内聚性，减少了对外交互，降低了系统的耦合性。
如果接口的粒度大小定义合理，能够保证系统的稳定性；但是，如果定义过小，则会造成接口数量过多，使设计复杂化；如果定义太大，灵活性降低，无法提供定制服务，给整体项目带来无法预料的风险。
使用多个专门的接口还能够体现对象的层次，因为可以通过接口的继承，实现对总接口的定义。
能减少项目工程中的代码冗余。过大的大接口里面通常放置许多不用的方法，当实现这个接口的时候，被迫设计冗余的代码。

实现

问题由来：
类A通过接口I依赖类B，类C通过接口I依赖类D，如果接口I对于类A和类B来说不是最小接口，则类B和类D必须去实现他们不需要的方法。
解决方案：
将臃肿的接口I拆分为独立的几个接口，类A和类C分别与他们需要的接口建立依赖关系。也就是采用接口隔离原则。

实例

不遵循接口隔离原则

类A依赖接口I中的方法1、方法2、方法3，类B是对类A依赖的实现。类C依赖接口I中的方法1、方法4、方法5，类D是对类C依赖的实现。对于类B和类D来说，虽然他们都存在着用不到的方法（也就是图中红色字体标记的方法），但由于实现了接口I，所以也必须要实现这些用不到的方法。

interface I {
    void method1();
    void method2();
    void method3();
    void method4();
    void method5();
}

class A {
    public void depend1(I i) {
        i.method1();
    }
    public void depend2(I i) {
        i.method2();
    }
    public void depend3(I i) {
        i.method3();
    }
}

class B implements I {
    @Override
    public void method1() {
        System.out.println("B实现了接口I的方法1");
    }
    @Override
    public void method2() {
        System.out.println("B实现了接口I的方法2");
    }
    @Override
    public void method3() {
        System.out.println("B实现了接口I的方法3");
    }
    @Override
    public void method4() {}
    @Override
    public void method5() {}
}

class C {
    public void depend1(I i) {
        i.method1();
    }
    public void depend2(I i) {
        i.method4();
    }
    public void depend3(I i) {
        i.method5();
    }
}

class D implements I {
    @Override
    public void method1() {
        System.out.println("D实现了接口I的方法1");
    }
    @Override
    public void method2() { }
    @Override
    public void method3() { }
    @Override
    public void method4() {
        System.out.println("D实现了接口I的方法4");
    }
    @Override
    public void method5() {
        System.out.println("D实现了接口I的方法5");
    }
}

public class ISPClient {
    public static void main(String[] args) {
        A a = new A();
        a.depend1(new B());
        a.depend2(new B());
        a.depend3(new B());

        C c = new C();
        c.depend1(new D());
        c.depend2(new D());
        c.depend3(new D());
    }
}

输出结果：
B实现了接口I的方法1
B实现了接口I的方法2
B实现了接口I的方法3
D实现了接口I的方法1
D实现了接口I的方法4
D实现了接口I的方法5

可以看到，如果接口过于臃肿，只要接口中出现的方法，不管对依赖于它的类有没有用处，实现类中都必须去实现这些方法，这显然不是好的设计。如果将这个设计修改为符合接口隔离原则，就必须对接口I进行拆分

遵循接口隔离原则

采用接口隔离原则，将接口I拆分成多个独立的接口I1，I2，I3

interface I1 {
    void method1();
}

interface I2 {
    void method2();
    void method3();
}

interface I3 {
    void method4();
    void method5();
}

class A {
    public void depend1(I1 i) {
        i.method1();
    }
    public void depend2(I2 i) {
        i.method2();
    }
    public void depend3(I2 i) {
        i.method3();
    }
}

class B implements I1, I2 {
    @Override
    public void method1() {
        System.out.println("B实现了接口I的方法1");
    }
    @Override
    public void method2() {
        System.out.println("B实现了接口I的方法2");
    }
    @Override
    public void method3() {
        System.out.println("B实现了接口I的方法3");
    }
}

class C {
    public void depend1(I1 i) {
        i.method1();
    }
    public void depend2(I3 i) {
        i.method4();
    }
    public void depend3(I3 i) {
        i.method5();
    }
}

class D implements I1, I3 {
    @Override
    public void method1() {
        System.out.println("D实现了接口I的方法1");
    }
    @Override
    public void method4() {
        System.out.println("D实现了接口I的方法4");
    }
    @Override
    public void method5() {
        System.out.println("D实现了接口I的方法5");
    }
}

public class ISPClient {
    public static void main(String[] args) {
        A a = new A();
        a.depend1(new B());
        a.depend2(new B());
        a.depend3(new B());

        C c = new C();
        c.depend1(new D());
        c.depend2(new D());
        c.depend3(new D());
    }
}

输出结果：
B实现了接口I的方法1
B实现了接口I的方法2
B实现了接口I的方法3
D实现了接口I的方法1
D实现了接口I的方法4
D实现了接口I的方法5

可以看到，用户只需要维护关心的方法实现，可以预防外来变更的扩散，提高系统的灵活性和可维护性

接口隔离原则VS单一职责原则

单一职责原则注重的是职责;接口隔离原则注重的是对接口依赖的隔离
单一职责原则主要约束类，其次才是接口和方法，它针对的是程序中的细节和实现;接口隔离原则主要约束接口，主要针对抽象，针对程序整体框架的构建

采用接口隔离原则对接口约束，需注意：

接口尽量小，但是要有限度。如果过小，则会造成接口数量过多，使设计复杂化。所以一定要适度。
为依赖接口的类定制服务，只暴露给调用的类它需要的方法，它不需要的方法则隐藏起来。只有专注地为一个模块提供定制服务，才能建立最小的依赖关系。
提高内聚，减少对外交互。使接口用最少的方法去完成最多的事情。