Java中接口隔离原则简介和代码举例

手搓DesignPattern

于 2025-03-15 18:23:43 发布

阅读量350

点赞数 3

文章标签：接口隔离原则 java

本文链接：https://blog.csdn.net/m0_73892800/article/details/146283140

版权

简介：

接口隔离原则（Interface Segregation Principle，ISP）是面向对象设计SOLID原则中的“I”，其核心思想是：

定义

客户端不应被迫依赖它不使用的方法。即，一个类对另一个类的依赖应建立在最小的接口上，避免实现臃肿的接口。

核心思想

拆分“胖接口”
将包含多个功能的庞大接口拆分为多个小而专注的接口，每个接口代表一个特定的职责。
按需实现
类只需实现与自身功能相关的接口，避免因实现无关方法而引入冗余或错误（如空方法、抛异常等）。

与单一职责原则（SRP）的区别
SRP：关注类的职责单一性（一个类只做一件事）。
ISP：关注接口的细粒度设计（一个接口只服务一个功能模块）。

实践建议

按角色划分接口
如用户权限系统中，将AdminRole（管理权限）和GuestRole（浏览权限）分离，避免普通用户类被迫实现管理员方法。
组合优于继承
通过组合多个小接口实现灵活的功能复用，而非继承一个庞大接口。
识别依赖边界
若某个接口的部分方法被多个类频繁忽略，说明需要拆分。

优势

降低耦合：减少类之间的不必要依赖。
提高可维护性：接口变更的影响范围更小。
增强灵活性：通过组合接口实现功能的按需扩展。

代码举例：

假如有ABCD四个类，A,C需要依赖B，D类中的方法，B，D依赖一个类

下列示例中发现，B和D都有多余的方法，因为A只依赖了1，2，3方法，4，5没有依赖

interface interface1{
    void operation1();
    void operation2();
    void operation3();
    void operation4();
    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");
    }
}//B
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");
    }
}//B
class A{//A类通过接口使用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();
    }
}//B
class C{
    public void depend1(interface1 i){
        i.operation1();
    }
    public void depend2(interface1 i){
        i.operation4();
    }
    public void depend3(interface1 i){
        i.operation5();
    }
}

代码改善：

通过对接口的拆分，使得B，D都依赖了最小接口，没有造成浪费

interface interface1{
    void operation1();
}
//接口2
interface interface2{
    void operation2();
    void operation3();
}
//接口3
interface interface3{
    void operation4();
    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");
    }

}//B
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");
    }
}//B
class A{//A类通过接口使用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();
    }
}//A
class C{
    public void depend1(interface1 i){
        i.operation1();
    }
    public void depend2(interface3 i){
        i.operation4();
    }
    public void depend3(interface3 i){
        i.operation5();
    }
}