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

一、基本介绍

不应该依赖不需要的接口，即一个类对另一个类的依赖应该建立在最小的接口上。

使用多个专门的接口比使用单一的总接口要好。换而言之，接口尽量细化，接口中的方法尽量少。过于臃肿的接口是对接口的污染。不应该强迫依赖于它们不用的方法：

接口隔离原则与单一职责原则
单一职责要求的是类和接口职责单一，注重的是职责，没有要求接口的方法减少，例如一个职责可能包含10个方法，这10个方法都放在一个接口中，并且提供给多个模块访问，各个模块按照规定的权限来访问，在系统外通过文档约束不使用的方法不要访问，这符合单一职责原则，却不符合接口隔离原则，因为接口隔离原则要求“尽量使用多个专门的接口”,专门的接口指什么？就是指提供给多个模块的接口，提供给几个模块就应该有几个接口，而不是建立一个庞大的臃肿的接口，所有的模块可以来访问。

二、实例

场景
1.Interface1共有1,2,3,4,5方法。
2.类B实现接口Interface1 ，类A通过接口Interface1依赖(使用)类B，但是只会用到1,2,3方法
3.类D实现接口Interface1 ，类C通过接口Interface1依赖(使用)类D，但是只会用到1,4,5方法

代码

//接口
interface Interface1 {
	void operation1();
	void operation2();
	void operation3();
	void operation4();
	void operation5();
}

//类B实现接口Interface1 
class B implements Interface1 {
    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" ); 
    }
    
    public void operation5() {
        System. out.println("B实现了operation5"); 
    }
}

//类D实现接口Interface1 
class D implements Interface1 {
    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" ); 
    }

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

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

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

public class segregation {
    public static void main(String[] args) {
        A a=new A();
        C c=new C();
//类A 通过接口 依赖类B
        a.depend1(new B());
        a.depend2(new B());
        a.depend3(new B());
//类C 通过接口 依赖类D
        c.depend1(new D());
        c.depend4(new D());
        c.depend5(new D());
    }
}

运行结果：
B实现了operation1
B实现了operation2
B实现了operation3
D实现了operation1
D实现了operation4
D实现了operation5

类A通过接口Interface1依赖类B，类C通过接口Interface1依赖类D， 如果接口 Interface1对于类A和类C来说不是最小接口，那么类B和类D必须去实现它们不需要的方法。
如上代码违背了接口隔离原则(不应该依赖不需要的接口，即一个类对另一个类的依赖应该建立在最小的接口上)类A不需要用到类B 4,5方法，类C不需要用到类D 2,3方法

解决方法:
接口Interface1拆分为独立的几个接口，类A和类C分别与它们需要的接口建立依赖关系。也就是采用接口隔离原则。

接口Interface1 中出现的方法，根据实际情况拆分为三个接口：代码实现
interface Interface1 {
    void operation1();
}
interface Interface2 {
    void operation2();
    void operation3();
}
interface Interface3 {
    void operation4();
    void operation5();
}

类B 实现接口Interface1 ,Interface2的所有方法
class B implements Interface1,Interface2 {
    public void operation1() {
        System.out.println("B 实现 operation1");
    }
    public void operation2() {
        System.out.println("B 实现 operation2");
    }
    public void operation3() {
        System.out.println("B 实现 operation3");
    }
}

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

类D实现接口Interface1,Interface3 的所有方法
class D implements Interface1,Interface3 {
    public void operation1() {
        System.out.println("D 实现 operation1");
    }
    public void operation4() {
        System.out.println("D 实现 operation4");
    }
    public void operation5() {
        System.out.println("D 实现 operation5");
    }
}

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