设计模式原则之接口隔离原则

                                                                                                        接口隔离原则

1.什么是接口隔离原则

• Clients should not be forced to depend upon interfaces that they don't use.（客户端不应该强行依赖它不需要的接口）
• The dependency of one class to another one should depend on the smallest possible interface.（类间的依赖关系应该建立在最小的接口上）

       通过简单的代码还原开篇的问题

需求如下

类A通过接口会依赖（使用）类C 但是类A只会使用到接口中的1,2,3方法

类B通过接口会依赖（使用）类D 但是类B只会使用到接口中的1,4,5方法

最初的接口中有五个方法

---

版本一

类A

public class ClassA {

    public void dependOnInterfaceOperationOne(InterfaceOriginal interfaceOriginal){
        interfaceOriginal.operation1();
    }

    public void dependOnInterfaceOperationTwo(InterfaceOriginal interfaceOriginal){
        interfaceOriginal.operation2();
    }

    public void dependOnInterfaceOperationThree(InterfaceOriginal interfaceOriginal){
        interfaceOriginal.operation3();
    }


}

　类B

public class ClassB {

    public void dependOnInterfaceOperationOne(InterfaceOriginal interfaceOriginal){
        interfaceOriginal.operation1();
    }

    public void dependOnInterfaceOperationFour(InterfaceOriginal interfaceOriginal){
        interfaceOriginal.operation4();
    }

    public void dependOnInterfaceOperationFive(InterfaceOriginal interfaceOriginal){
        interfaceOriginal.operation5();
    }
}

　类C

public class ClassC implements InterfaceOriginal {

    public void operation1(){
        System.out.println("ClassC has implements operation1");
    }

    public void operation2(){
        System.out.println("ClassC has implements operation2");
    }

    public void operation3(){
        System.out.println("ClassC has implements operation3");
    }

    public void operation4(){
        System.out.println("ClassC has implements operation4");
    }

    public void operation5(){
        System.out.println("ClassC has implements operation5");
    }
}

类D

public class ClassD implements InterfaceOriginal{

    public void operation1(){
        System.out.println("ClassD has implements operation1");
    }

    public void operation2(){
        System.out.println("ClassD has implements operation2");
    }

    public void operation3(){
        System.out.println("ClassD has implements operation3");
    }

    public void operation4(){
        System.out.println("ClassD has implements operation4");
    }

    public void operation5(){
        System.out.println("ClassD has implements operation5");
    }

}

接口类

public interface InterfaceOriginal {
    void operation1();
    void operation2();
    void operation3();
    void operation4();
    void operation5();
}

Main函数类

public class ClassMain {
    public static void main(String[] args) {

        ClassA classA=new ClassA();
        classA.dependOnInterfaceOperationOne(new ClassC());
        classA.dependOnInterfaceOperationTwo(new ClassC());
        classA.dependOnInterfaceOperationThree(new ClassC());

        System.out.println("-------------");

        ClassB classB=new ClassB();
        classB.dependOnInterfaceOperationOne(new ClassD());
        classB.dependOnInterfaceOperationFour(new ClassD());
        classB.dependOnInterfaceOperationFive(new ClassD());
    }
}

控制台显示情况

 UML类图

类A只用到了InterfaceOriginal接口中的OperationOne,OperationTwo,OperationThree.

类B只用到了InterfaceOriginal接口中的OperationOne,OperationFour,OperationFive

但是类A和类B同时依赖了不需要的接口 或者是说类间依赖的接口不是最小的 这就违反了接口隔离原则

---

从以上代码可以看出，如果接口过于臃肿，不同业务逻辑的抽象方法都放在一个接口内，则会造成它的实现类必须实现自己并不需要的方法，这种设计方式显然是不妥当的。所以我们要修改上述设计方法，把接口InterfaceOriginal拆分成3个接口，使得实现类只需要实现自己需要的接口即可。只贴出修改后的接口和实现类的代码，修改代码如下：

类A

public class ClassA {

    public void dependOnSegregationInterfaceOne(SegregationInterfaceOne interfaceOne){
        interfaceOne.operationOne();
    }

    public void dependOnSegregationInterfaceTwo(SegregationInterfaceTwo interfaceTwo){
        interfaceTwo.operationTwo();
        interfaceTwo.operationThree();
    }

}

类B

public class ClassB {

    public void dependOnSegregationInterfaceOne(SegregationInterfaceOne interfaceOne){
        interfaceOne.operationOne();
    }

    public void dependOnSegregationInterfaceThree(SegregationInterfaceThree interfaceThree){
        interfaceThree.operationFour();
        interfaceThree.operationFive();
    }
}

类C

public class ClassC implements SegregationInterfaceOne,SegregationInterfaceTwo{

    public void operationOne(){
        System.out.println("ClassC has implements operationOne");
    }

    public void operationTwo(){
        System.out.println("ClassC has implements operationTwo");
    }

    public void operationThree(){
        System.out.println("ClassC has implements operationThree");
    }

}

类D

public class ClassD implements SegregationInterfaceOne,SegregationInterfaceThree{

    public void operationOne(){
        System.out.println("ClassD has implements operationOne");
    }

    public void operationFour(){
        System.out.println("ClassD has implements operationFour");
    }

    public void operationFive(){
        System.out.println("ClassD has implements operationFive");
    }
}

　隔离接口1

public interface SegregationInterfaceOne {
    void operationOne();
}

　隔离接口2

public interface SegregationInterfaceTwo {
    void operationTwo();
    void operationThree();
}

　隔离接口3

public interface SegregationInterfaceThree {
    void operationFour();
    void operationFive();
}

Main函数类

public class MainClass {

    public static void main(String[] args) {

        ClassA classA = new ClassA();
        classA.dependOnSegregationInterfaceOne(new ClassC());
        classA.dependOnSegregationInterfaceTwo(new ClassC());

        System.out.println("----------------------");
        ClassB classB = new ClassB();
        classB.dependOnSegregationInterfaceOne(new ClassD());
        classB.dependOnSegregationInterfaceThree(new ClassD());
    }
}

控制台运行结果

 UML类图

 这下类A和类B依赖的接口就是最小的 符合接口隔离原则

---

与单一职责原则的区别

　　到了这里，有些人可能觉得接口隔离原则与单一职责原则很相似，其实不然。

　　第一，单一职责原则注重的是职责；而接口隔离原则注重对接口依赖的隔离。

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

注意事项

　　原则是前人经验的总结，在软件设计中具有一定的指导作用，但是不能完全照搬这些原则。对于接口隔离原则来说，接口尽量小，但是也要有限度。对接口进行细化可以提高程序设计灵活性是不争的事实，但是如果过小，则会造成接口数量过多，使设计复杂化，所以一定要适度。