接口隔离原则

未使用隔离

/**
 * 
 */
package com.pro.princle.segregation;

/**
 * @author kans
 *
 */
public class Segregation {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

	}

}
interface Interface1{
	 public void  operation1();
	 public void  operation2();
	 public void  operation3();
	 public void  operation4();
	 public void  operation5();
}

class B implements Interface1{
	
	@Override
	public void operation1() {
		System.out.println("B实现了operation1");
	}

	
	@Override
	public void operation2() {
		System.out.println("B实现了operation2");
	}

	
	@Override
	public void operation3() {
		System.out.println("B实现了operation3");
	}

	
	@Override
	public void operation4() {
		System.out.println("B实现了operation4");
	}

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

class D implements Interface1{
	
	@Override
	public void operation1() {
		System.out.println("D实现了operation1");
	}

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

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

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

	@Override
	public void operation5() {
		System.out.println("D实现了operation5");
	}
	
}
class A{//A类通过接口Interface会 依赖(使用)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类通过接口Interface会 依赖(使用)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();
	}
}

改进使用接口隔离

package com.pro.princle.segregation.improve;

/**
 * @author kans
 *
 */
public class Segregation1 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		A a = new A();
		a.depend1(new B());// A通过接口去依赖B
		a.depend2(new B());
		a.depend3(new B());

		C c = new C();
		c.depend1(new D());// C通过接口去依赖D类
		c.depend4(new D());
		c.depend5(new D());

	}

}

interface Interface1 {
	public void operation1();
}

interface Interface2 {
	public void operation2();

	public void operation3();
}

interface Interface3 {

	public void operation4();

	public void operation5();
}

class B implements Interface1, Interface2 {

	@Override
	public void operation1() {
		System.out.println("B 实现了operation1");
	}

	@Override
	public void operation2() {
		System.out.println("B 实现了operation2");
	}

	@Override
	public void operation3() {
		System.out.println("B 实现了operation3");
	}

}

class D implements Interface3, Interface1 {

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

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

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

}

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

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

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

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

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

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