设计模式之---接口隔离原则

基本概念：类与类之间的依赖通过最小的接口 实现。
一个违反接口隔离原则的实例：

实现类

public class Segregation {

	public static void main(String[] args) {
		A a = new A();
		a.depend1(new B());
		a.depend2(new B());
		a.depend3(new B());
		D d = new D();
		d.operation1();
		d.operation4();
		d.operation5();
	}

	
}
//接口
	interface Interface1 {
		void operation1();

		void operation2();

		void operation3();

		void operation4();

		void operation5();
	}

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

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

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

		public void depend2(Interface1 i) {
			i.operation2();
		}

		public void depend3(Interface1 i) {
			i.operation3();
		}
	}

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

		public void depend4(Interface1 i) {
			i.operation4();
		}

		public void depend5(Interface1 i) {
			i.operation5();
		}
	}
运行结果：
B 实现了 operation1
B 实现了 operation2
B 实现了 operation3
D 实现了 operation1
D 实现了 operation4
D 实现了 operation5

分析：

1. 类A和类C都实现接口Interface1的所有方法，而B和D类都只用到了接口中的一些方法。
2. 接口拆分。将interface1拆分成interface2和interface3和interface1三个接口。

接口隔离实例：

public class SegregationIprov {

	public static void main(String[] args) {
		AT a = new AT();
		a.depend1(new BT());
		a.depend2(new BT());
		a.depend3(new BT());
		CT d = new CT();
		d.depend1(new DT());
		d.depend4(new DT());
		d.depend5(new DT());
	}

}

//接口
interface Interface {
	void operation1();
}

interface Interface2 {
	void operation2();

	void operation3();
}

interface Interface3 {
	void operation4();

	void operation5();
}

class BT implements Interface, 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");
	}

	 

}

class DT implements Interface, 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");
	}
}

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

	public void depend2(Interface2 i) {
		i.operation2();
	}

	public void depend3(Interface2 i) {
		i.operation3();
	}
}

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

	public void depend4(Interface3 i) {
		i.operation4();
	}

	public void depend5(Interface3 i) {
		i.operation5();
	}
}

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

分析：进行接口拆分，类只实现和他们相关的接口方法。做到接口的隔离。