设计模式七大原则 (2)——接口隔离原则

最新推荐文章于 2024-11-18 21:27:10 发布

星辰之眼

最新推荐文章于 2024-11-18 21:27:10 发布

阅读量120

点赞数 1

分类专栏：设计模式文章标签：设计模式 java

本文链接：https://blog.youkuaiyun.com/qq_36965149/article/details/109278529

版权

设计模式专栏收录该内容

17 篇文章

订阅专栏

本文介绍了接口隔离原则(ISP)的基本概念及其在软件设计中的应用。通过对比不符合ISP的例子与符合ISP的设计，阐述了如何通过合理拆分接口来提高程序灵活性，并避免不必要的方法实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1、定义

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

2、应用实例

2.1不符合接口隔离原则

在这里插入图片描述

这个图的意思是：

类A依赖接口Ⅰ中的方法1、2、3，类B是对类A的依赖实现；
类C依赖接口Ⅰ中的方法1、4、5，类D是对类C的依赖实现；
对于类B和D来说，由于它们实现接口Ⅰ，虽然它们存在用不到的方法，但是必须要去实现

代码

interface Interface {
    void ope1();
    void ope2();
    void ope3();
    void ope4();
    void ope5();
}

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

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

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

    // 由于实现接口，所以必须实现这两个方法
    @Override
    public void ope4() {}
    @Override
    public void ope5() {}
}

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

    // 由于实现接口，所以必须实现这两个方法
    @Override
    public void ope2() {}
    @Override
    public void ope3() {}

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

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

class A {
    public void depend1(Interface i) {
        i.ope1();
    }

    public void depend2(Interface i) {
        i.ope2();
    }

    public void depend3(Interface i) {
        i.ope3();
    }
}

class C {
    public void depend1(Interface i) {
        i.ope1();
    }

    public void depend4(Interface i) {
        i.ope4();
    }

    public void depend5(Interface i) {
        i.ope5();
    }
}

public class Client {
    public static void main(String[] args) {
        A a = new A();
        a.depend1(new B());
        a.depend2(new B());
        a.depend3(new B());

        C c = new C();
        c.depend1(new D());
        c.depend4(new D());
        c.depend5(new D());
    }
}

接口中出现的方法，不论对依赖它的类有没有用，实现类都必须去实现这些方法，这并不是一个好的设计。
所以，我们可以将接口Ⅰ进行拆分，根据情况，最好将接口Ⅰ拆分为三个接口。

2.2 符合接口隔离原则

在这里插入图片描述

我们将接口Ⅰ拆分为接口Ⅰ、接口Ⅱ和接口Ⅲ

类A依赖接口Ⅰ中的方法1，接口Ⅱ中的方法2、3，类B是对类A的依赖实现；
类C依赖接口Ⅰ中的方法1，接口Ⅲ中的方法4、5，类D是对类C的依赖实现。

代码

interface Interface0 {
    void ope1();
}

interface Interface1 {
    void ope2();
    void ope3();
}

interface Interface2 {
    void ope4();
    void ope5();
}

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

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

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

class D implements Interface0, Interface2 {
    @Override
    public void ope1() {
        System.out.println("B 实现了 ope1");
    }

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

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

class A {
    public void depend1(Interface0 i) {
        i.ope1();
    }

    public void depend2(Interface1 i) {
        i.ope2();
    }

    public void depend3(Interface1 i) {
        i.ope3();
    }
}

class C {
    public void depend1(Interface0 i) {
        i.ope1();
    }

    public void depend4(Interface2 i) {
        i.ope4();
    }

    public void depend5(Interface2 i) {
        i.ope5();
    }
}

public class Test01 {
    public static void main(String[] args) {
        A a = new A();
        a.depend1(new B());
        a.depend2(new B());
        a.depend3(new B());

        C c = new C();
        c.depend1(new D());
        c.depend4(new D());
        c.depend5(new D());
    }
}