设计模式六大原则（4）：接口隔离原则（出自韩顺平老师讲义）

设计模式六大原则（4）：接口隔离原则

• 定义
• 问题由来
• 解决方案

定       义：客户端不应该依赖它不需要的接口；一个类对另一个类的依赖应该建立在最小的接口上。

问题由来：类A通过接口I依赖类B，类C通过接口I依赖类D，如果接口I对于类A和类B来说不是最小接口，则类B和类D必须去实现他们不需要的方法。

解决方案：将臃肿的接口I拆分为独立的几个接口，类A和类C分别与他们需要的接口建立依赖关系。也就是采用接口隔离原则。

下面我们举例来说明一下接口隔离原则：

图1.Yangxiaoyuan

                                                                                 （图1 未遵循接口隔离原则的设计）

这个图的意思是：类A依赖接口I中的方法1、方法2、方法3，类B是对类A依赖的实现。类C依赖接口I中的方法4、方法5，类D是对类C依赖的实现。对于类B和类D来说，虽然它们都存在着用不到的方法（也就是图1.Yangxiaoyuan中的红色字体标记的方法），但是由于我们实现了接口I，所以也必须实现这些用不到的方法。对类图还看不明白的话，我们下面使用一个程序代码来帮助理解，代码如下：

//定义接口I
interface I{
    public void method1();
    public void method2();
    public void method3();
    public void method4();
    public void method5();
}

//定义一个class A
class A{
    public void depend1(I i){
        i.method1();
}
    public void depend2(I i){
        i.method2();
}
    public void depend3(I i){
        i.method3();
}
}

//定义class A 让它实现接口I
class B implements I{
    public void method1(){
        System.out.println("类B实现接口I的方法1");
}
    public void method2(){
        System.out.println("类B实现接口I的方法2");
}
    public void method3(){
        System.out.println("类B实现接口I的方法3");
}

/**对于类B来说，method4和method5不是必须要实现的，但是由于接口I中有这两个方法，所以
*，我们在实现的过程中，即使这两个方法的方法体为空，我们也要将这两个没有作用的方法进行实现。
*/
    public void method4(){
       
}
    public void method5(){
        
}
}

//定义class C
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让它实现接口I
class D implements I{
    public void method1(){
        System.out.println("类D实现接口I的方法1");
}

/**
*对于类D来说，method2和method3不是必须要实现的，但是由于接口I中有这两个方法，所以，我们在
*实现的过程中即使这两个方法的方法体为空，我们也要将这两个没有作用的方法进行实现。
*/
    public void method2(){
        
}
    public void method3(){
        
}
    public void method4(){
        System.out.println("类D实现接口I的方法4");
}
    public void method5(){
        System.out.println("类D实现接口I的方法5");
}
}


//接下来我们定义测试类
public class Client{
    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());
}

不难看出，如果接口过于臃肿，只要接口中出现的方法，不管是对依赖于它的类有没有用处，实现类中都必须去实现这些没有用的方法，这样设计显然不行。如果将这个设计修改为符合接口隔离原则，就必须对接口I进行拆分。在这里我们将原有的接口I拆分为三个接口，拆分后如下：图2.

图2.Yangxiaoyuan

                                                                       （图2.Yangxiaoyuan遵循接口隔离原则的设计）

照例写出陈旭代码，以便不熟悉类图的朋友参考：

inteface I1{
    public void method1();
}

inteface I2{
    public void method2();
    public void method3();
}


inteface I3{
    public void method4();
    public void method5();
}


//定义class A
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 让它实现接口 I1 I2
class B implements I1, I2{
    public void method1(){
        System.out.pritnln("类B实现接口I1的方法1");
}

    public void method2(){
        System.out.pritnln("类B实现接口I2的方法2");
}

    public void method3(){
        System.out.pritnln("类B实现接口I2的方法3");
}
}

//定义class C
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，让它实现接口I1，I3
class D implements I1,I3{
    public void method1(){
        System.out.println("类D实现接口I1中的方法1");
}
    public void method4(){
        System.out.println("类D实现接口I3中的方法4");
}
    public void method5(){
        System.out.println("类D实现接口I3中的方法5");
}
}

接口隔离原则的含义：建立单一接口，不要建立庞大的臃肿的接口，尽量细化接口，接口中的方法尽量少，也即是说，我们要为各个类建立专用的接口，而不要试图去建立一个很庞大的接口供所有依赖它的类去调用。这篇文章的例子中，将一个很庞大的接口I分为三个I1,I2,I3。将其变更为3个专用的接口说采用的就是接口隔离原则。在程序设计中，依赖几个专用的接口要比依赖一个综合的接口要来得方便，更灵活。接口是在设计的时间对外部设定的“契约”，通过分散定义多个接口，可以预防外来变更的扩散，提高系统的灵活性和可维护性。

刚开始的话我感觉接口隔离原则和单一职责原则很相似，后来我试了几次之后发现，其实不然。第一：单一职责原则注重的是职责；而接口隔离原则注重的是对接口依赖的隔离。第二：单一职责原则主要是约束类，其次才是接口和方法，它针对的是程序中的实现和细节；而接口隔离原则主要约束接口，主要针对抽象，针对程序整体框架的构建。

采用接口隔离原则对接口进行约束的时间，要注意以下几点：

1. 接口尽量小，但是要有限度。对接口进行细化可以提高程序设计灵活性是不争的事实，但是如果过小，则会造成接口数量过多，使设计复杂化。所以一定要适中。
2. 为依赖接口的类定制服务，只暴露给定义的类它需要的方法，它不需要的方法则隐藏起来。只有专注的为一个模块提供服务，才能建立小的依赖关系。
3. 提高内聚，减少对外交互。使接口用最少的方法完成最多的事情。
4. 运用接口隔离原则，一定要适度，接口设计的过大或者过小都不好。设计接口的时候，只有多花时间去思考和筹划，才能准确的实践这一原则。