接口隔离原则

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

2.看图

 

package com.xx.isolation;

public interface Interface1 {
    void function();

    void function1();

    void function2();

    void function3();
}

package com.xx.isolation;

/**
 * 1.A类想通过Interface1依赖使用B类
 * 2.但是A类只用到了function，function1,function2.
 */
public class A {
    public void relyOn(Interface1 interface1) {
        interface1.function();
    }

    public void relyOn1(Interface1 interface1) {
        interface1.function1();
    }

    public void relyOn2(Interface1 interface1) {
        interface1.function2();
    }

}

package com.xx.isolation;

public class B implements Interface1 {
    @Override
    public void function() {
        System.out.println("B类的function方法");
    }

    @Override
    public void function1() {
        System.out.println("B类的function1方法");
    }

    @Override
    public void function2() {
        System.out.println("B类的function2方法");
    }

    @Override
    public void function3() {
        System.out.println("B类的function3方法");
    }
}


package com.xx.isolation;

public class C {
    public void relyOn(Interface1 interface1) {
        interface1.function1();
    }

    public void relyOn1(Interface1 interface1) {
        interface1.function2();
    }

    public void relyOn2(Interface1 interface1) {
        interface1.function3();
    }
}


package com.xx.isolation;

public class D implements Interface1 {
    @Override
    public void function() {
        System.out.println("D类的function方法");
    }

    @Override
    public void function1() {
        System.out.println("D类的function1方法");
    }

    @Override
    public void function2() {
        System.out.println("D类的function2方法");
    }

    @Override
    public void function3() {
        System.out.println("D类的function3方法");
    }
}

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

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

       把Interface1分成多个接口，让类A和类C分别去与他们需要 的接口建立依赖关系。也就是采用接口隔离原则。

5.经过接口隔离分析后修改的图：

 

接口Interface出现的方法，根据实际情况拆分成三个接口。

代码实现：

public interface Interface1 {
    void method();
}


public interface Interface2 {
    public void method1() ;

    public void method2();
}


public interface Interface3 {
    void method3();
}


public  class A {
    public void function(Interface1 interface1) {
        interface1.method();
    }

    public void function1(Interface2 interface2) {
        interface2.method1();
    }

    public void function2(Interface2 interface2) {
        interface2.method2();
    }
}

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

    @Override
    public void method2() {
        System.out.println("实现了Interface2的method2");
    }

    @Override
    public void method() {
        System.out.println("实现了Interface1的method方法");
    }
}

public class C {
    public void function(Interface2 interface2) {
        interface2.method1();
    }

    public void function1(Interface2 interface2) {
        interface2.method2();
    }

    public void function2(Interface3 interface3) {
        interface3.method3();
    }
}

public class D implements Interface3, Interface2 {
    @Override
    public void method1() {
        System.out.println("实现了Interface2的method1");
    }

    @Override
    public void method2() {
        System.out.println("实现了Interface2的method2");
    }

    @Override
    public void method3() {
        System.out.println("实现了Interface3的method3");
    }
}

public class Test {
    public static void main(String[] args) {
        A a = new A();
        a.function(new B());
        a.function1(new B());
        a.function1(new B());

        C c = new C();
        c.function(new D());
        c.function1(new D());
        c.function2(new D());
    }
}

// 打印结果
实现了Interface1的method方法
实现了Interface2的method1
实现了Interface2的method1
实现了Interface2的method1
实现了Interface2的method2
实现了Interface3的method3