七大设计原则之接口隔离原则

一、接口隔离原则介绍

       客户端不应该依赖它不需要的接口，即一个类对另一个类的依赖应该建立在最小的接口上。初看这个定义，让人摸不着头脑，我们看一个类图，看如下图所示：

       类A通过接口Interface1依赖类B，类C通过接口Interface1依赖类D。如果接口Interface1对于类A和类C来说不是最小接口，也即类B只需要实现operation1、operation2、operation3方法，类D只需要实现operation1、operation2、operation4、operation5方法，那么类B和类D必须去实现他们不需要的方法 。

二、案例讲解

2.1传统方法

     类A通过接口Collector依赖类B，类C通过接口Collector依赖类D，代码如下：

public interface Collector{
    void remove();
    void add();
    void addAll();
    boolean contain();
}

public class B implements Collector{

    public void remove(){}

    public void add(){}

    public void addAll(){}

    public boolean contain(){}
}

public class D implements Collector{

    public void remove(){}

    public void add(){}

    public void addAll(){}

    public boolean contain(){}
}

public class A{
    public void depend1(Collector c){
        c.remove();
    }

    public void depend2(Collector c){
        c.add();
    }

    public void depend3(Collector c){
        c.addAll();
    }
}

public class C{
    public void depend1(Collector c){
        c.remove();
    }

    public void depend2(Collector c){
        c.add();
    }

    public boolean depend4(Collector c){
        return c.contain();
    }
}

public class Test{

    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.depend4(new D());
    }
}

       从上面的例子可以看出，类A通过接口Collector依赖到类B，但只会用到remove、add、addAll方法；类C通过接口Collector依赖类D，但是只会用到remove、add、contain方法，类图如下所示：

接口Collector对于类A和类C来说不是最小接口，类B和类D必须去实现他们不需要的方法。如果以后稍微修改了接口Collector，那么类B和类D都要一起修改。这样的实现方式不是很友好，不利于后期扩展。那该如何改进呢？

2.2使用接口隔离原则改进      

        按隔离原则应当这样处理：将接口Collector拆分为独立的几个接口，类A和类C分别与他们需要的接口建立依赖关系。代码改造如下：

public interface Collector{
    void remove();
    void add();
}

public interface Collector2{
    boolean contain();
}

public interface Collector3{
    void addAll();
}

public class B implements Collector, Collector3{

    public void remove(){}

    public void add(){}

    public void addAll(){}

}

public class D implements Collector, Collector2{

    public void remove(){}

    public void add(){}

    public boolean contain(){}
}

public class A{
    public void depend1(Collector c){
        c.remove();
    }

    public void depend2(Collector c){
        c.add();
    }

    public void depend3(Collector c){
        c.addAll();
    }
}

public class C{
    public void depend1(Collector c){
        c.remove();
    }

    public void depend2(Collector c){
        c.add();
    }

    public boolean depend4(Collector2 c){
        return c.contain();
    }
}

public class Test{

    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.depend4(new D());
    }
}

        从上面改造后的代码可以看出，类A通过接口Collector、接口Collector3依赖到类B，类C通过接口Collector、接口Collector2依赖类D，并不会出现像传统方法一样实现了多余的方法，类图如下所示：