面向对象的六大基本原则-------单一职责

• 单一职责(Single Responsibility Principle, 简称：SRP)
• 定义:应该有且仅有一个原因引起类的变更,也就是接口或类和职责的关系是一一对应的。
• 单一职责原则是实现高内聚、低耦合的指导方针，它是最简单但又最难运用的原则。为什么说难运用呢?
• ①因为在不通的场景和生产环境下我们队职责的细化是不同的，这也是职责单一的相对性。
• ②单一职责原则提出的是一个评价接口是否优良的标准，但是职责和变化原因是不可度量的，因项目而异，因环境而异(不可度量性)
• 单一职责的优点：
• ①类的复杂性降低，每个类或者接口都只实现一个职责，定义明确清晰
• ②由于职责单一，使得程序的可读性大大的增加
• ③可读性强，便于理解，可维护性就自然提高。而且职责单一所以类之间的耦合特别低，便于修改
• ④便于拓展 有新的职责需要拓展，只需要继承对应的接口实现新的实现就可以了
• 场景举例：

• 比如Pear是一家电子产品商，它要生产pad,phone,watch等设备，但是有一些重复的功能，如果分别设计一套，很显然并不划算，那么接口定义上我们就可以根据功能划分设定单一职责的接口:

  接口的定义

  //可以拨打电话
  interface Callable{
      void call ();
  }
  
  //可以触摸控制
  interface Touchable{
      void touch();
  }
  
  //可以消息提醒
  interface MessagePromptable{
      void prompt();
  }
  
  //可以接入键盘
  interface KeyBoardMatchable{
      void match();
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19

  实现接口的类依旧单一职责

• class StandardCall implements Callable{
  
      @Override
      public void call() {
          System.out.println("Call to somebody!");
      }
  }
  
  class StandardTouch implements Touchable{
  
      @Override
      public void touch() {
          System.out.println("touch to press the button!");
      }
  }
  
  class StandardPromt implements MessagePromptable{
  
      @Override
      public void prompt() {
          System.out.println(" someone contact to you,sir!");
      }
  }
  
  class StandardMatch implements KeyBoardMatchable{
  
      @Override
      public void match() {
          System.out.println("The keyBoard is ready to work!");
      }
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31

  产品的生产

  • 我们如果基于我们现有的技术生产一部手机，那么我们需要它能打电话，触屏控制和消息提醒:

  //在声明这台手机时我们就明确知道了它的功能
  class MyPhone implements Callable,MessagePromptable,Touchable{
  
      //无需重复研发已有的技术，直接装载即可
      private Callable caller = new StandardCall();
      private MessagePromptable prompter = new StandardPromt();
      private Touchable toucher = new StandardTouch();
  
      @Override
      public void call() {
          caller.call();
      }
  
      @Override
      public void prompt() {
          prompter.prompt();
      }
  
      @Override
      public void touch() {
          toucher.touch();
      }
  }
  
  public class SRPTest {
      public static void main ( String [] args ){
          MyPhone phone = new MyPhone();
          phone.call();
          phone.prompt();
          phone.touch();
      }
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32

  • 假如我们需要出一款新的手机，但是我们只是拥有了新的呼叫技术，那么只需要在实现这项技术时继承Callable接口，然后在之前手机的Callable的具体是凶案类换成新的技术即可，只需要修改一行代码，是不是感觉棒棒的。职责的单一，对于我们对于现有类的修改造成的影响有了约束
  • 那么如果我想生产一个Pad呢，同理啊，只需要在已有技术上装载即可啊，Pad类依旧只是单一的整合技术形成产品的职责，整合成产品和研发出技术的职责分离，为我们的类的拓展带来了方便

  class MyPad implements Touchable,KeyBoardMatchable{
  
      Touchable toucher = new StandardTouch();
      KeyBoardMatchable matcher = new StandardMatch();
  
      @Override
      public void match() {
          toucher.touch();
      }
  
      @Override
      public void touch() {
          matcher.match();
      }
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15