03接口隔离原则

基本介绍

客户端不应该依赖它不需要的接口，即一个类对另一个类的依赖应该建立在最小的接口上。应该使用多个专门的接口，而不是使用单一的总接口。

代码示例

interface MyIntf {
    void operation1();
    void operation2();
    void operation3();
    void operation4();
}

class B implements MyIntf {
    public void operation1() {
        System.out.println("B 实现了operation1");
    }
    public void operation2() {
        System.out.println("B 实现了operation2");
    }
    public void operation3() {
        System.out.println("B 实现了operation3");
    }
    public void operation4() {
        System.out.println("B 实现了operation4");
    }
}

class D implements MyIntf {
    public void operation1() {
        System.out.println("D 实现了operation1");
    }
    public void operation2() {
        System.out.println("D 实现了operation2");
    }
    public void operation3() {
        System.out.println("D 实现了operation3");
    }
    public void operation4() {
        System.out.println("D 实现了operation4");
    }
}

class A {
    public void depend1(MyIntf myIntf) {
        myIntf.operation1();
    }
    public void depend2(MyIntf myIntf) {
        myIntf.operation2();
    }
    public void depend3(MyIntf myIntf) {
        myIntf.operation3();
    }
}

class C {
    public void depend1(MyIntf myIntf) {
        myIntf.operation1();
    }
    public void depend2(MyIntf myIntf) {
        myIntf.operation2();
    }
    public void depend4(MyIntf myIntf) {
        myIntf.operation4();
    }
}

A类通过接口MyIntf 依赖（使用）B类，但是只会用到1 2 3方法，所以4方法是不需要实现的方法。
同理， C类通过接口MyIntf 依赖（使用）D类，但是只会用到1 2 4方法，所以3方法是不需要实现的。

改进：
把接口MyIntf 拆分成几个独立的接口，类A,C分别与他们需要的接口建立依赖关系，也就是采用接口隔离原则。
根据实际情况将MyIntf 拆为3个独立接口：

interface MyIntf1 {
    void operation1();
    void operation2();
}
interface MyIntf2 {
    void operation3();
}
interface MyIntf3 {
    void operation4();
}

class B2 implements MyIntf1, MyIntf2 {
    public void operation1() {
        System.out.println("B2 实现了operation1");
    }
    public void operation2() {
        System.out.println("B2 实现了operation2");
    }
    public void operation3() {
        System.out.println("B2 实现了operation3");
    }
}

class D2 implements MyIntf1, MyIntf3 {
    public void operation1() {
        System.out.println("D2 实现了operation1");
    }
    public void operation2() {
        System.out.println("D2 实现了operation2");
    }
    public void operation4() {
        System.out.println("D2 实现了operation4");
    }
}

class A2 {
    public void depend1(MyIntf1 myIntf) {
        myIntf.operation1();
        myIntf.operation2();
    }
    public void depend2(MyIntf2 myIntf) {
        myIntf.operation3();
    }
}

class C2 {
    public void depend1(MyIntf1 myIntf) {
        myIntf.operation1();
        myIntf.operation2();
    }
    public void depend3(MyIntf3 myIntf) {
        myIntf.operation4();
    }
}

public class Segretion02 {
    public static void main(String[] args) {
        // A类通接口去依赖B类
        A2 a2 = new A2();
        a2.depend1(new B2());
        a2.depend2(new B2());
        // C类通过接口去依赖D类
        C2 c2 = new C2();
        c2.depend1(new D2());
        c2.depend3(new D2());
    }
}

输出结果：

B2 实现了operation1
B2 实现了operation2
B2 实现了operation3
D2 实现了operation1
D2 实现了operation2
D2 实现了operation4

A类通过接口MyIntf1 MyIntf2 依赖（使用）B类，只会用到1 2 3方法
C类通过接口MyIntf1 MyIntf3依赖（使用）D类，只会用到1 2 4方法