2，单一职责原则(Single Responsibility Principle)

concept

There should never be more than one reason for a class to change.
引起一个类发生变化的原因有且仅有一个

---

analyse

1. 单一职责原则将不同的职责分离到单独的类中，每一个【职责】都是类的【变化中心】
2. 类的职责主要包括两个方面：数据职责和行为职责
   》数据职责通过其属性来体现，
   》行为职责通过其方法来体现
3. 符合单一职责原则的类中，每一个职责都是中心，当需求发生变动时，只需要修改相应的类，就能做出相应的调整

在SRP中，将职责定义为类变化的原因。如果一个类拥有多于一个的职责，则多个职责耦合在一起，会有多余一个原因来导致这个类发生变化。一个职责的变化可能会影响到其他的职责，另外把多个职责耦合在一起会影响类的复用性

---

example

统计一个文本文件里面有少个英文单词

public String singleResponsibilityPrincipleCounterexample( String filePath) throws IOException {    
     // 加载文件
     BufferedReader bufferedReader = new BufferedReader(new FileReader(new File(filePath)));
     StringBuffer stringBuffer = new StringBuffer();
     while (bufferedReader.readLine() != null) {
            stringBuffer.append(bufferedReader.readLine());
            stringBuffer.append(" ");
     }
     bufferedReader.close();
     
     // 将文件中的单词分割出来
     String[] words = stringBuffer.toString().split("[^0-9 (0-9a-zA-Z0-9\\\\u4e00-\\\\u9fa5) \\\\（）() ())（$]");
     Map<String, Integer> map = new HashMap<>();
     for (String word : words) {
            if (map.containsKey(word)) {
                map.put(word, map.get(word) + 1);
            } else {
                map.put(word, 1);
            }
       }
      List<Map.Entry<String, Integer>> list = new ArrayList<>(map.entrySet());
      StringBuffer stringBuffer = new StringBuffer();
     int n = 0;
     for (Map.Entry<String, Integer> entry : list) {
            stringBuffer.append("[单词:" + entry.getKey() + "------频次" + entry.getValue() + "]");
            n = n + entry.getValue();
      }
     return "文本中单词共计:" + n + "              " + stringBuffer;
}

假设，此时需求调整为统计文本中的中文字符数量，那么上述方法已经不适用该需求，需要重写上述方法，这样会大大降低开发效率。而且与【高内聚，低耦合】的思想背道而驰。
所以，根据SRP对上述代码进行优化，将职责定义为【方法】变化的中心，将不同的职责分离到单独的方法中。

public String singleResponsibilityPrinciple() throws IOException {
        String fileString = loadFile(filePath);
        String filterCharacters = filterCharacters(fileString);
        String[] words = getWords(fileString);
       return getWordsNum(words);
}


 /**
     * 加载文件
     * @param filePath
     * @return
     * @throws IOException
*/
public String loadFile(String filePath) throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new FileReader(new File(filePath)));
        StringBuffer stringBuffer = new StringBuffer();
        while (bufferedReader.readLine() != null) {
            stringBuffer.append(bufferedReader.readLine());
            stringBuffer.append(" ");
        }
        bufferedReader.close();
        return stringBuffer.toString();
}

/** 
     * 过滤出英文单词
     * @param fileString
     * @return
*/
public String filterCharacters(String fileString) {
        String regex = "[^0-9 (0-9a-zA-Z0-9\\\\u4e00-\\\\u9fa5) \\\\（）() ())（$]";
        return fileString.replaceAll(regex, " ");
}

/**
     * 得到字符中的单词
     * @param str
     * @return
 */
    public String[] getWords(String str) {
        return str.split(" ");
}

 /**
     * 计算字符总数，并输出单词以及词频
     * @param words
     * @return
     */
public String getWordsNum(String[] words) {
        Map<String, Integer> map = new HashMap<>();
        for (String word : words) {
            if (map.containsKey(word)) {
                map.put(word, map.get(word) + 1);
            } else {
                map.put(word, 1);
            }
        }
        List<Map.Entry<String, Integer>> list = new ArrayList<>(map.entrySet());
        StringBuffer stringBuffer = new StringBuffer();
        int n = 0;
        for (Map.Entry<String, Integer> entry : list) {
            stringBuffer.append("[字符" + entry.getKey() + "------频次" + entry.getValue() + "]");
            n = n + entry.getValue();
        }
        return "文本中字符共计:" + n + "              " + stringBuffer;
}

---

根据职责对 方法/类/框架 进行划分，能够提高一个程序的可扩展性，同时降低了代码的耦合

单一职责原则可以看做是低耦合、高内聚在面向对象原则上的引申，将职责定义为引起变化的原因，以提高内聚性来减少引起变化的原因。
职责过多，可能引起它变化的原因就越多，这将导致职责依赖，相互之间就产生影响，从而大大损伤其内聚性和耦合度。
单一职责原则是从类的功能的角度去设计，将不同的职责分别归于不同的类中，这样使得设计更加清晰、易修改。

---