【设计模式】接口隔离原则

原则概述：客户端不应该依赖它不需要的接口，即一个类对另一个类的依赖应该建立在最小的接口上

如图中，【对象B】依赖【类D】，【对象C】依赖【类E】，但【类D】和【类E】都依赖于【接口A】。按照实现接口的规则，【类D】和【类E】都应该实现【接口A】中所有的方法。但，【类B】只需要实现接口中【function1】【function2】【function3】三个方法，【类E】则需要实现接口中的【function1】【function4】【function5】。显然两个类中都要实现不需要的方法。违背了【接口隔离原则】。

要符合【接口隔离原则】，可以通过如下修改。

interface A{
    void function1();
}

interface B{
    void function2();
    void function3();
}

interface C{
    void function4();
    void function5();
}
class D implements A,B {

    public void function1() {
        System.out.println("实现了方法1...");
    }

    public void function2() {
        System.out.println("实现了方法2...");
    }

    public void function3() {
        System.out.println("实现了方法3...");
    }
}

class E implements A,C {

    public void function1() {
        System.out.println("实现了方法1...");
    }

    public void function4() {
        System.out.println("实现了方法4...");
    }

    public void function5() {
        System.out.println("实现了方法5...");
    }
}

class F {
    public void operation1(A i) {
        i.function1();
    }
    public void operation2(B i) {
        i.function2();
    }
    public void operation3(B i) {
        i.function3();
    }
}

class G {
    public void operation1(A i) {
        i.function1();
    }
    public void operation4(C i) {
        i.function4();
    }
    public void operation5(C i) {
        i.function5();
    }
}
public class InterfaceSegregation {
    public static void main(String[] args) {
        F f = new F();
        f.operation1(new D());  // F类通过接口依赖D类
        f.operation2(new D());
        f.operation3(new D());

        G g = new G();
        g.operation1(new E()); // G类通过接口依赖E类
        g.operation4(new E());
        g.operation5(new E());

    }
}

修改后的【UML图】如下图所示：