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

接口隔离原则

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依赖的接口就是最小的符合接口隔离原则

与单一职责原则的区别

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

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

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

注意事项

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

posted on 2019-10-19 22:18 低调的小郭阅读(270) 评论(0) 收藏举报