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

设计模式七大原则之接口隔离原则（Interface Segeration Principle）

1.接口隔离原则介绍

一个类对另一个类的依赖应该建立在最小的接口上，如果建立在不是最小的接口上，则要实现不需要的方法违背接口隔离原则。

2.案例分析

场景： interface1是一个接口，有五个方法，C和D分别实现了interface1接口，A通过interface1对C产生依赖，但只需要用到function1,function2,function3三个方法，B通过interface1对C产生依赖，但只需要用到function1,function4,function5三个方法

传统解决方法：
只有一个接口，类图如下：

代码实现：

package com.ldx.segera;

public class Segeration {
    public static void main(String[] args) {
        A a = new A();
        C c = new C();
        a.function1(c);
        a.function2(c);
        a.function3(c);

        B b = new B();
        D d = new D();
        b.function1(d);
        b.function4(d);
        b.function5(d);
    }
}

interface interface1 {
    void function1();

    void function2();

    void function3();

    void function4();

    void function5();
}

class C implements interface1 {
    @Override
    public void function1() {
        System.out.println("C 中实现了 方法1");
    }

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

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

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

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

class D implements interface1 {
    @Override
    public void function1() {
        System.out.println("D 中实现了 方法1");
    }

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

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

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

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

class A {
    public void function1(interface1 i) {
        i.function1();
    }

    public void function2(interface1 i) {
        i.function2();
    }

    public void function3(interface1 i) {
        i.function3();
    }
}

class B {
    public void function1(interface1 i) {
        i.function1();
    }

    public void function4(interface1 i) {
        i.function4();
    }

    public void function5(interface1 i) {
        i.function5();
    }
}

运行结果：

运行结果是没有问题的，也解决了场景需求，但是类C和D却实现了不需要的其他两个方法。这就相对于一个工厂个人，他本来只需要负责搬货，但是你还要强制他去当客服，这显然是不合理的。

解决方法：接口隔离
将interface1分解成三个接口interface1（负责function1），interface2（负责function2，function3），interface3（负责function4，function5），C分别实现了interface1和interface2，D分别实现了interface1和interface3，A通过对interface1和interface2的依赖对C产生依赖，B通过对interface1和interface3的依赖对D产生依赖，类图如下：

代码实现：

package com.ldx.segera.com.ldx.segeration;

public class Segeration {
    public static void main(String[] args) {
        A a = new A();
        C c = new C();
        a.function1(c);
        a.function2(c);
        a.function3(c);

        B b = new B();
        D d = new D();
        b.function1(d);
        b.function4(d);
        b.function5(d);
    }
}

interface interface1 {
    void function1();
}

interface interface2 {

    void function2();

    void function3();

}

interface interface3 {

    void function4();

    void function5();
}

class C implements interface1, interface2 {
    @Override
    public void function1() {
        System.out.println("C 中实现了 方法1");
    }

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

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

class D implements interface1, interface3 {
    @Override
    public void function1() {
        System.out.println("D 中实现了 方法1");
    }

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

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

class A {
    public void function1(interface1 i) {
        i.function1();
    }

    public void function2(interface2 i) {
        i.function2();
    }

    public void function3(interface2 i) {
        i.function3();
    }
}

class B {
    public void function1(interface1 i) {
        i.function1();
    }

    public void function4(interface3 i) {
        i.function4();
    }

    public void function5(interface3 i) {
        i.function5();
    }
}

运行结果：

小结
接口隔离原则要求一个类对另一个类的依赖要建立在最小接口上，否则会承担不需要的职责。
七大设计原则汇总：七大设计原则汇总