设计模式六大原则之二：接口隔离原则

1 基本介绍

接口隔离原则(Interface Segregation Principle)：客户端不应该依赖它不需要的接口，即一个类对另一个类的依赖应该建立在最小的接口上。

2 案例演示

如上图，类B，类D都是接口I的实现，其中类A通过接口I依赖B，使用方法1，2，3但是B却还要实现方法4，5；类C通过接口I依赖D，使用方法1，4，5但是D却还要实现方法2，3。

public class Segregation1 {
    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.depend4(new D());
        c.depend5(new D());
    }
}
interface OptInterface {
    void opt1();
    void opt2();
    void opt3();
    void opt4();
    void opt5();
}
class B implements OptInterface {
    public void opt1() { System.out.println("B	实现了 opt1"); }
    public void opt2() { System.out.println("B	实现了 opt2"); }
    public void opt3() { System.out.println("B	实现了 opt3"); }
    public void opt4() { System.out.println("B	实现了 opt4"); }
    public void opt5() { System.out.println("B	实现了 opt5"); }
}
class D implements OptInterface {
    public void opt1() { System.out.println("D	实现了 opt1"); }
    public void opt2() { System.out.println("D	实现了 opt2"); }
    public void opt3() { System.out.println("D	实现了 opt3"); }
    public void opt4() { System.out.println("D	实现了 opt4"); }
    public void opt5() { System.out.println("D	实现了 opt5"); }
}
// A类通过接口OptInterface依赖（使用）B类，但是只会用到1，2，3方法
class A {
    public void depend1(OptInterface i) {i.opt1();}
    public void depend2(OptInterface i) {i.opt2();}
    public void depend3(OptInterface i) {i.opt3();}
}
// C类通过接口OptInterface依赖（使用）D类，但是只会用到1，4，5方法
class C {
    public void depend1(OptInterface i) {i.opt1();}
    public void depend4(OptInterface i) {i.opt4();}
    public void depend5(OptInterface i) {i.opt5();}
}

解决方式：将接口拆分为几个独立的接口，类A和类C分别与他们需要的接口建立依赖关系。如下：

public class Segregation2 {
    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.depend4(new D());
        c.depend5(new D());
    }
}
interface OptInterface {
    void opt1();
}
interface OptInterfaceB {
    void opt2();
    void opt3();
}
interface OptInterfaceD {
    void opt4();
    void opt5();
}
class B implements OptInterface,OptInterfaceB {
    public void opt1() { System.out.println("B	实现了 opt1"); }
    public void opt2() { System.out.println("B	实现了 opt2"); }
    public void opt3() { System.out.println("B	实现了 opt3"); }
}
class D implements OptInterface,OptInterfaceD {
    public void opt1() { System.out.println("D	实现了 opt1"); }
    public void opt4() { System.out.println("D	实现了 opt4"); }
    public void opt5() { System.out.println("D	实现了 opt5"); }
}
class A {
    public void depend1(OptInterface i) {i.opt1();}
    public void depend2(OptInterfaceB i) {i.opt2();}
    public void depend3(OptInterfaceB i) {i.opt3();}
}
class C {
    public void depend1(OptInterface i) {i.opt1();}
    public void depend4(OptInterfaceD i) {i.opt4();}
    public void depend5(OptInterfaceD i) {i.opt5();}
}