1.2 接口隔离原则

接口隔离原则

基本介绍

1. 客户端不应该依赖它不需要的接口，即一个类对另一个类的依赖应该建立在最小的接口上

2. 如图所示

   

3. 类 A 通过接口 Interface1 依赖类 B，类 C 通过接口 Interface1 依赖类 D，如果接口 Interface1 对于类 A 和类 C 来说不是最小接口，那么类 B 和类 D 必须去实现他们不需要的方法。

4. 按隔离原则应当这样处理：

   将接口 Interface1 拆分为独立的几个接口(这里我们拆分成 3 个接口)，类 A 和类 C 分别与他们需要的接口建立依赖关系。也就是采用接口隔离原则

应用实例

类 A 通过接口 Interface1 依赖类 B，类 C 通过接口 Interface1 依赖类 D，请编写代码完成此应用实例。

没有使用接口隔离原则代码

public class Segregation1 {

}

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

class B1 implements Interface11{
	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");
	}
}
class D1 implements Interface11{
	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 A1 {
	public void depend1(Interface11 i) {
		i.operation1();
	}
	public void depend2(Interface11 i) {
		i.operation2();
	}
	public void depend3(Interface11 i) {
		i.operation3();
	}
}

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

应传统方法的问题和使用接口隔离原则改进

1. 类 A 通过接口 Interface1 依赖类 B，类 C 通过接口 Interface1 依赖类 D，如果接口 Interface1 对于类 A 和类 C 来说不是最小接口，那么类 B 和类 D 必须去实现他们不需要的方法
2. 将接口 Interface1 拆分为独立的几个接口，类 A 和类 C 分别与他们需要的接口建立依赖关系。也就是采用接口隔离原则

3. 接口 Interface1 中出现的方法，根据实际情况拆分为三个接口

   

public class Segregation2 {

}

// 接口
interface Interface21{
	void operation1();
}
// 接口
interface Interface22{
	void operation2();
	void operation3();
}
// 接口
interface Interface23{
	void operation4();
	void operation5();
}

class B2 implements Interface21,Interface22{
	public void operation1() {
		System.out.println("B 实现operation1");
	}
	public void operation2() {
		System.out.println("B 实现operation2");
	}
	public void operation3() {
		System.out.println("B 实现operation3");
	}
}
class D2 implements Interface21,Interface23{
	public void operation1() {
		System.out.println("D 实现operation1");
	}
	public void operation4() {
		System.out.println("D 实现operation4");
	}
	public void operation5() {
		System.out.println("D 实现operation5");
	}
}


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

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


pend1(Interface21 i) {
		i.operation1();
	}
	public void depend4(Interface23 i) {
		i.operation4();
	}
	public void depend5(Interface23 i) {
		i.operation5();
	}
}