设计模式的七大原则——接口隔离原则

接口隔离原则的使用：

1. 类A通过接口Interface1依赖B，类C通过接口Interface1依赖D，如果接口Inter1,对于类A和类C来说不是最小接口，那么类B和类D必须实现他们不需要的方法

实现下面类图的结构: 

 

实现过程： 

接口interface1:

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

类A：

public class A {//A类通过接口Interface1 依赖（使用）B类，但是只会用到1，2，3方法
    public void depend1(Interface1 i){
        i.operation1();
    }
    public void depend2(Interface1 i){
        i.operation2();
    }
    public void depend3(Interface1 i){
        i.operation3();
    }
}

类B：

public class B implements Interface1{
    @Override
    public void operation1() {
        System.out.println("B实现了operation1()");
    }

    @Override
    public void operation2() {
        System.out.println("B实现了operation2()");
    }

    @Override
    public void operation3() {
        System.out.println("B实现了operation3()");
    }

    @Override
    public void operation4() {
        System.out.println("B实现了operation4()");
    }

    @Override
    public void operation5() {
        System.out.println("B实现了operation5()");
    }
}

类C：

public class C {//C类通过接口Interface1 依赖（使用）D类，但是只会用到1，4，5方法
    public void depend1(Interface1 i){
        i.operation1();
    }
    public void depend4(Interface1 i){
        i.operation4();
    }
    public void depend5(Interface1 i){
        i.operation5();
    }
}

类D：

public class D implements Interface1{
    @Override
    public void operation1() {
        System.out.println("D实现了operation1()");
    }

    @Override
    public void operation2() {
        System.out.println("D实现了operation2()");
    }

    @Override
    public void operation3() {
        System.out.println("D实现了operation3()");
    }

    @Override
    public void operation4() {
        System.out.println("D实现了operation4()");
    }

    @Override
    public void operation5() {
        System.out.println("D实现了operation5()");
    }

}

 ​​​​​​

 

 上面代码实现了，类图设计却违反了设计模式的接口隔离模式，因为，在B类中实现了不需要的方法，D类中实现了没有用到的方法。

那么如何解决呢？？？？

1. 将接口Interface1拆分为独立的几个接口，类A，类C分别与他们所需要的接口建立依赖关系，也就是实现了接口隔离原则
2. 将接口Interface1中出现的方法，根据实际拆分为三个接口

 改进过程：

 

接口interface1:

public interface Interface1 {
    void operation1();
}

 接口interface2:

public interface Interface2 {
    void operation2();
    void operation3();
}

 接口interface3:

public interface Interface3 {
    void operation4();
    void operation5();
}

类A：

public class A {//A类通过接口Interface1 依赖（使用）B类，但是只会用到1，2，3方法
    public void depend1(Interface1 i){
        i.operation1();
    }
    public void depend2(Interface2 i){
        i.operation2();
    }
    public void depend3(Interface2 i){
        i.operation3();
    }
}

类B：

public class B implements Interface1,Interface2{
    @Override
    public void operation1() {
        System.out.println("B实现了operation1()");
    }

    @Override
    public void operation2() {
        System.out.println("B实现了operation2()");
    }

    @Override
    public void operation3() {
        System.out.println("B实现了operation3()");
    }

}

类C：

public class C {//C类通过接口Interface1 依赖（使用）D类，但是只会用到1，4，5方法
    public void depend1(Interface1 i){
        i.operation1();
    }
    public void depend4(Interface3 i){
        i.operation4();
    }
    public void depend5(Interface3 i){
        i.operation5();
    }
}

类D:

public class D implements Interface1,Interface3{
    @Override
    public void operation1() {
        System.out.println("D实现了operation1()");
    }

    @Override
    public void operation4() {
        System.out.println("D实现了operation4()");
    }

    @Override
    public void operation5() {
        System.out.println("D实现了operation5()");
    }
}

结果：

虽然实现结果一样，但是改进后的B类与D类，并没有实现A类与C类，未使用的方法，使用最小接口就是，遵循着接口隔离原则。