接口隔离_2

2 接口隔离原则
客户端不应该依赖它不需要的接口，即一个类对应另一个类的以来应该建立在最小的接口上
类A通过接口Interface1依赖类B，类C通过接口Interface1依赖类D，如果接口Interface1对于类A和类C来说不是最小接口，那么类B和类D必须去实现他们不需要的方法。
2.1应用实例
类A通过接口Interface1依赖类B，
类C通过接口Interface1依赖类D，

public class Segregation1 {

    /**
     *  A类通过接口Inteface1 依赖B类，只会使用1，2，3方法
     *  C类通过接口Inteface1 依赖D类，只会使用1，4，5方法
     *  下面的此种方式满足需求，但是此种凡是有些方式并不需要，需要改进
     */
    public static void main(String[] args) {

    }
}

//接口
interface Interface1{
    void method1();
    void method2();
    void method3();
    void method4();
    void method5();
}

class B implements Interface1{

    @Override
    public void method1() {
        System.out.println("class B implement Interface1 method1");
    }

    @Override
    public void method2() {
        System.out.println("class B implement Interface1 method2");
    }

    @Override
    public void method3() {
        System.out.println("class B implement Interface1 method3");
    }

    @Override
    public void method4() {
        System.out.println("class B implement Interface1 method4");
    }

    @Override
    public void method5() {
        System.out.println("class B implement Interface1 method5");
    }
}

class D implements Interface1{

    @Override
    public void method1() {
        System.out.println("class D implement Interface1 method1");
    }

    @Override
    public void method2() {
        System.out.println("class D implement Interface1 method2");
    }

    @Override
    public void method3() {
        System.out.println("class D implement Interface1 method3");
    }

    @Override
    public void method4() {
        System.out.println("class D implement Interface1 method4");
    }

    @Override
    public void method5() {
        System.out.println("class D implement Interface1 method5");
    }
}

/**
 *  A类通过接口Inteface1 依赖B类，只会使用1，2，3方法
 */
class A {
    public void depend1(Interface1 i1){
        i1.method1();
    }
    public void depend2(Interface1 i1){
        i1.method2();
    }
    public void depend3(Interface1 i1){
        i1.method3();
    }
}

/**
 *  C类通过接口Inteface1 依赖D类，只会使用1，4，5方法
 */
class C {
    public void depend1(Interface1 i1){
        i1.method1();
    }
    public void depend4(Interface1 i1){
        i1.method4();
    }
    public void depend5(Interface1 i1){
        i1.method5();
    }
}

改进 将接口Interface1拆分成3个接口

public class Segregation2 {

    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()); //A类通过接口去依赖B类
        c.depend4(new D());
        c.depend5(new D());
    }
}


//接口1
interface Interface1{
    void method1();
}

//接口2
interface Interface2{
    void method2();
    void method3();
}

//接口3
interface Interface3{
    void method4();
    void method5();
}

class B implements Interface1,Interface2{

    @Override
    public void method1() {
        System.out.println("class B implement Interface1 method1");
    }

    @Override
    public void method2() {
        System.out.println("class B implement Interface1 method2");
    }

    @Override
    public void method3() {
        System.out.println("class B implement Interface1 method3");
    }
}

class D implements Interface1,Interface3{

    @Override
    public void method1() {
        System.out.println("class D implement Interface1 method1");
    }

    @Override
    public void method4() {
        System.out.println("class D implement Interface1 method4");
    }

    @Override
    public void method5() {
        System.out.println("class D implement Interface1 method5");
    }
}

/**
 *  A类通过接口Inteface1，Interface2 依赖B类，只会使用1，2，3方法
 */
class A {
    public void depend1(Interface1 i){
        i.method1();
    }
    public void depend2(Interface2 i){
        i.method2();
    }
    public void depend3(Interface2 i){
        i.method3();
    }
}

/**
 *  C类通过接口Inteface1 ，Interface3  依赖D类，只会使用  1，4，5方法
 */
class C {
    public void depend1(Interface1 i){
        i.method1();
    }
    public void depend4(Interface3 i){
        i.method4();
    }
    public void depend5(Interface3 i){
        i.method5();
    }
}

接口隔离原则总结
1)类A通过接口Interface1依赖类B,类C通过Interface1依赖类D,如果接口Interface1对于类A和类C来说不是最小接口，那么类B和类D必须去实现他们不需要的方法
2）将接口Interafce1拆分成几个独立的接口，类A和类C分别与他们需要的几口建立依赖关系，也就是采用接口隔离原则。
3）接口Interface1中出现的方法，根据实际情况拆分为三个接口。