七大设计原则-接口隔离原则

前言

设计模式相关文章主要来自B站尚硅谷的学习视频的心得 B站视频传送门
设计模式系列文章传送门23种设计模式系列合集
有空会慢慢更新学习心得，相关源码在 Github

---

基本介绍

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

• 先看一张图:

  

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

• 按隔离原则应当这样处理：

将接口 Interface1 拆分为独立的几个接口(这里我们拆分成 3 个接口)，类 A 和类 C 分别与他们需要的接口建立

依赖关系。也就是采用接口隔离原则

---

应用实例

• 类 A 通过接口 Interface1 依赖类 B，类 C 通过接口 Interface1 依赖类 D，请编写代码完成此应用实例。

• 没有使用接口隔离原则代码

  package learn.lhb.design.patterns.principle.segregation;
  
  /**
   * 接口隔离原则案例 1
   *
   * @author 梁鸿斌
   * @date 2020/3/14.
   * @time 22:43
   */
  public class Segregation1 {
  
      public static void main(String[] args) {
  
      }
  }
  
  interface Interface1{
      /**
       * 方法1
       */
      void operation1();
  
      /**
       * 方法2
       */
      void operation2();
  
      /**
       * 方法3
       */
      void operation3();
  
      /**
       * 方法4
       */
      void operation4();
  
      /**
       * 方法5
       */
      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");
      }
  }
  
  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 类通过接口Interface 依赖使用 B类，但只会用到1，2，3方法
   */
  class A {
      public void depen1(Interface1 i) {
          i.operation1();
      }
      public void depen2(Interface1 i) {
          i.operation2();
      }
      public void depen3(Interface1 i) {
          i.operation3();
      }
  }
  
  /**
   * C 类通过接口Interface 依赖使用 D类，但只会用到1，4, 5方法
   */
  class C {
      public void depen1(Interface1 i) {
          i.operation1();
      }
      public void depen4(Interface1 i) {
          i.operation4();
      }
      public void depen5(Interface1 i) {
          i.operation5();
      }
  }
  

  应传统方法的问题和使用接口隔离原则改进

  • 类 A 通过接口 Interface1 依赖类 B，类 C 通过接口 Interface1 依赖类 D，如果接口 Interface1 对于类 A 和类 C

  来说不是最小接口，那么类 B 和类 D 必须去实现他们不需要的方法

  • 将接口 Interface1 拆分为独立的几个接口，类 A 和类 C 分别与他们需要的接口建立依赖关系。也就是采用接口

  隔离原则

  • 接口 Interface1 中出现的方法，根据实际情况拆分为三个接口

• 代码改进

package learn.lhb.design.patterns.principle.segregation.improve;

/**
 * 接口隔离原则案例 2
 * 案例 1的改进，实现接口隔离的最小接口数原则
 *
 * @author 梁鸿斌
 * @date 2020/3/14.
 * @time 22:43
 */
public class Segregation1 {

    public static void main(String[] args) {
        A a = new A();
        // A 类通过接口去依赖 B类
        a.depen1(new B());
        a.depen2(new B());
        a.depen3(new B());

        C c = new C();
        // C 类通过接口去依赖 D类
        c.depen1(new D());
        c.depen4(new D());
        c.depen5(new D());
    }
}

/**
 * 接口1
 */
interface Interface1{
    /**
     * 方法1
     */
    void operation1();

}

/**
 * 接口2
 */
interface Interface2{

    /**
     * 方法2
     */
    void operation2();

    /**
     * 方法3
     */
    void operation3();
}

/**
 * 接口3
 */
interface Interface3{

    /**
     * 方法4
     */
    void operation4();

    /**
     * 方法5
     */
    void operation5();
}

/**
 * B 类实现接口1，接口2里面的方法1，2，3
 */
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 类实现接口1，接口3里面的方法1，4， 5
 */
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");
    }
}

/**
 * A 类通过接口Interface 依赖使用 B类，但只会用到1，2，3方法
 */
class A {
    public void depen1(Interface1 i) {
        i.operation1();
    }
    public void depen2(Interface2 i) {
        i.operation2();
    }
    public void depen3(Interface2 i) {
        i.operation3();
    }
}

/**
 * C 类通过接口Interface 依赖使用 D类，但只会用到1，4, 5方法
 */
class C {
    public void depen1(Interface1 i) {
        i.operation1();
    }
    public void depen4(Interface3 i) {
        i.operation4();
    }
    public void depen5(Interface3 i) {
        i.operation5();
    }
}

---

有问题欢迎私信/评论指出，谢谢您的观看，希望对您有帮助哦！
https://lianghongbin.blog.csdn.net/