接口隔离原则

接口隔离原则

基本的介绍：

客户端当中的类不应该依赖他所不需要的类，即一个类对另外一个类的依赖应该建立在最小的接口上面来的。

原始接口的处理

使用UML图来对其进行相应的解释操作

使用代码来对其功能的实现：

接口：

package com.yt.isolationInterface;

/**
 * @program: designPattern
 * @description
 * @author: YangTao
 * @create: 2024-02-20 13:18
 **/
public interface Interface1 {
    void operation1();

    void operation2();

    void operation3();

    void operation4();

    void operation5();
}

类B和类D

package com.yt.isolationInterface;

/**
 * @program: designPattern
 * @description
 * @author: YangTao
 * @create: 2024-02-20 13:38
 **/
public 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的功能");
    }
}

package com.yt.isolationInterface;

/**
 * @program: designPattern
 * @description
 * @author: YangTao
 * @create: 2024-02-20 13:38
 **/
public 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的功能");
    }
}

类A和类C

package com.yt.isolationInterface;

/**
 * @program: designPattern
 * @description
 * @author: YangTao
 * @create: 2024-02-20 13:40
 **/
public class A {
    public void operation1(Interface1 i){
        i.operation1();
    }
    public void operation2(Interface1 i){
        i.operation2();
    }
    public void operation3(Interface1 i){
        i.operation3();
    }
}

package com.yt.isolationInterface;

/**
 * @program: designPattern
 * @description
 * @author: YangTao
 * @create: 2024-02-20 13:41
 **/
public class C {
    public void operation1(Interface1 i){
        i.operation1();
    }
    public void operation4(Interface1 i){
        i.operation4();
    }
    public void operation5(Interface1 i){
        i.operation5();
    }
}

对应功能的实现操作处理

package com.yt.isolationInterface;


/**
 * @program: designPattern
 * @description
 * @author: YangTao
 * @create: 2024-02-20 13:42
 **/
public class IsolationInterfaceTest {
    public static void main(String[] args) {
        A a = new A();
        a.operation1(new B());
        a.operation2(new B());
        a.operation3(new B());
        System.out.println("-------------");
        C c = new C();
        c.operation1(new D());
        c.operation4(new D());
        c.operation5(new D());

    }
}

实现的结果：

这样的功能实现起来，原则上是可以对代码进行完成的，但是有一点问题是功能是完成了，有的代码是没有什么用处的。对于实现了那个接口的类而言。代码是没有用的，但是又不能将其进行删除。

那么在编写代码的过程当中，可以将接口进行拆分来进行处理操作。使得想要直接实现的类可以能够准确的实现相对应的接口。对于本类当中不需要的方法能直接进行删除操作的。实现对应的接口就可以了。

优化接口的处理

进行优化之后的代码：

代码实现其对应的功能操作

接口1：

package com.yt.isolationInterface.optimizeOperation;

/**
 * @program: designPattern
 * @description
 * @author: YangTao
 * @create: 2024-02-20 20:09
 **/
public interface Interface1 {
    void operation1();
}

接口2：

package com.yt.isolationInterface.optimizeOperation;
​
/**
 * @program: designPattern
 * @description
 * @author: YangTao
 * @create: 2024-02-20 20:10
 **/
public interface Interface2 {
    void operation2();
​
    void operation3();
​
}

​

接口3：

package com.yt.isolationInterface.optimizeOperation;
​
/**
 * @program: designPattern
 * @description
 * @author: YangTao
 * @create: 2024-02-20 20:10
 **/
public interface Interface3 {
    void operation4();
​
    void operation5();
}

​

A：

package com.yt.isolationInterface.optimizeOperation;
​
/**
 * @program: designPattern
 * @description
 * @author: YangTao
 * @create: 2024-02-20 20:13
 **/
public class A {
    public void operation1(Interface1 i){
        i.operation1();
    }
​
    public void operation2(Interface2 i){
        i.operation2();
    }
​
    public void operation3(Interface2 i){
        i.operation3();
    }
}

C：

package com.yt.isolationInterface.optimizeOperation;
​
/**
 * @program: designPattern
 * @description
 * @author: YangTao
 * @create: 2024-02-20 20:15
 **/
public class C {
    public void operation1(Interface1 i){
        i.operation1();
    }
​
    public void operation4(Interface3 i){
        i.operation4();
    }
​
    public void operation5(Interface3 i){
        i.operation5();
    }
}

B：

package com.yt.isolationInterface.optimizeOperation;
​
/**
 * @program: designPattern
 * @description
 * @author: YangTao
 * @create: 2024-02-20 20:11
 **/
public 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的方法");
    }
}

D:

package com.yt.isolationInterface.optimizeOperation;
​
/**
 * @program: designPattern
 * @description
 * @author: YangTao
 * @create: 2024-02-20 20:12
 **/
public class D implements Interface1 , Interface3{
    @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的方法");
    }
}

代码测试的样例：

package com.yt.isolationInterface.optimizeOperation;
​
/**
 * @program: designPattern
 * @description
 * @author: YangTao
 * @create: 2024-02-20 20:16
 **/
public class OptimizeOperationTest {
    public static void main(String[] args) {
        A a = new A();
        a.operation1(new B());
        a.operation2(new B());
        a.operation3(new B());
​
        C c = new C();
        c.operation1(new D());
        c.operation4(new D());
        c.operation5(new D());
​
    }
}

得到的结果：