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

接口隔离原则（ISP）

接口隔离原则基本介绍
不应该依赖不需要的接口，即一个类对另一个类的依赖应该建立在最小的接口上。
场景:
1.类B实现接口Interface1 ，类A通过接口Interface1依赖(使 用)类B，但是只会用到1,2,3方法
2.类D实现接口Interface1 ，类C通过接口Interface1依赖(使 用)类D，但是只会用到1,4,5方法

public class ISP {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		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());
	}
}

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();
	}
}

接口隔离原则

• 类A通过接口Interface1依赖类B
• 类C通过接口Interface1依赖类D
• 如果接口 Interface1对于类A和类C来说不是最小接口，那么类B和类D必须去实现它们不需要的方法。
• 如上代码违背了接口隔离原则(不应该依赖不需要的接口，即一个类对另一个类的依赖应该建立在最小的接口上) 类A不需要用到类B 4,5方法类C不需要用到类D 2,3方法
• 按隔离原则应当这样处理:
  将接口Interface1拆分为独立的几个接口， 类A和类C分别与他们需要的接口建立依赖关系。也就是采用接口隔离原则

public class ISP {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		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());

	}
}

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();
	}
}

• 接口隔离原则：使用多个专门的接口比使用单一的总接口要好。换而言之，接口尽量细化,接口中的方法尽量少。
• 过于臃肿的接口是对接口的污染。不应该强迫依赖于它们不用的方法：类A通过接口I依赖类B，类C通过接口I依赖类D，如果接口I对于类A和类C来说不是最小接口，而类B和类D必须去实现它们不需要的方法。
  接口隔离原则与单一职责原则
  它们定义的规则不同：
  单一职责要求的是类和接口职责单一，注重的是职责，没有要求接口的方法减少，例如一个职责可能包含10个方法，这10个方法都放在一个接口中，并且提供给多个模块访问，各个模块按照规定的权限来访问，在系统外通过文档约束不使用的方法不要访问，这符合单一职责原则，却不符合接口隔离原则，因为接口隔离原则要求“尽量使用多个专门的接口”,专门的接口指么？就是指提供给多个模块的接口，提供给几个模块就应该有几个接口，而不是建立一个庞大的臃肿的接口，所有的模块可以来访问。