【设计模式】六原则(一)单一职责

本文最后更新于：2021年12月13日 下午

单一原则（Single Responsibility Principle, SRP）

1、定义

一个类或者一个方法只应该负责相应的功能职责，支撑高内聚低耦合，最简单但是运用最难的原则

2、 优点

1
2
3
4
1. 降低代码之间的耦合度；
2. 提高代码可读性；
3. 提高系统的可维护性；
4. 降低后续的变更可能引起的风险。

3、示例

先来看一个示例 模拟人的各种活动

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package cc.niushuai.study.designpattern.sixprinciples.single.entity;

import lombok.AllArgsConstructor;
import lombok.Data;

/**
 * 人 实体类
 *
 * @author niushuai233
 * @date 2021/10/18 11:31:40
 */
@Data
@AllArgsConstructor
public class People {

    private String name;

    public void doSomething(String something) {
        System.out.println(this.getName() + "要去" + something + "...");
    }
}

Main 主类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package cc.niushuai.study.designpattern.sixprinciples.single;

import cc.niushuai.study.designpattern.sixprinciples.single.entity.People;

/**
 * 主类
 *
 * @author niushuai
 * @date: 2021/10/18 11:32:55
 */
public class Main {

    public static void main(String[] args) {
        People people = new People("张三");
        people.doSomething("吃饭");
        people.doSomething("喝水");
        people.doSomething("跑步");
    }

}

运行结果：

1
2
3
张三要去吃饭...
张三要去喝水...
张三要去跑步...

现在我们加点东西, 比如吃饭的时候分早中晚餐等

1
2
3
4
5
6
7
8
9
10
public void doSomething(String something) {
    System.out.println(this.getName() + "要去" + something + "...");
    if (something.equals("吃饭")) {
        System.out.println("吃的早饭");
    } else if (something.equals("跑步")) {
        System.out.println("去公园跑步");
    } else if (something.equals("喝水")) {
        System.out.println("喝的白开水");
    }
}

运行结果：

1
2
3
4
5
6
张三要去吃饭...
吃的早饭
张三要去喝水...
喝的白开水
张三要去跑步...
去公园跑步

此时我们可以看到, 如果要修改吃饭的相关逻辑, 那么势必会影响跑步和喝水的逻辑

因此下一步我们把他拆开来看, 解耦合， 所以我们需要重新对方法进行设计

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public void eat(String eatType) {
    if ("breakfast".equals(eatType)) {
        System.out.println(this.getName() + "吃早饭...");
    } else if ("lunch".equals(eatType)) {
        System.out.println(this.getName() + "吃午饭...");
    } else if ("dinner".equals(eatType)) {
        System.out.println(this.getName() + "吃晚饭...");
    }
}

public void drink(String drinkType) {
    if ("water".equals(drinkType)) {
        System.out.println(this.getName() + "喝白开水...");
    } else if ("cola".equals(drinkType)) {
        System.out.println(this.getName() + "喝可乐...");
    } else if ("wine".equals(drinkType)) {
        System.out.println(this.getName() + "喝白酒...");
    }
}

主方法：

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
package cc.niushuai.study.designpattern.sixprinciples.single;

import cc.niushuai.study.designpattern.sixprinciples.single.entity.People;

/**
 * 主类
 *
 * @author niushuai
 * @date: 2021/10/18 11:32:55
 */
public class Main {

    public static void main(String[] args) {
        People people = new People("张三");

        // people.doSomething("吃饭");
        // people.doSomething("喝水");
        // people.doSomething("跑步");

        // 吃的动作
        people.eat("breakfast");
        people.eat("dinner");

        // 喝的动作
        people.drink("water");
        people.drink("wine");
    }
}

运行结果:

1
2
3
4
张三吃早饭...
张三吃晚饭...
张三喝白开水...
张三喝白酒...

修改后则eat和drink方法都分开了，eat不会负责drink的事情, 因此达到了解耦，实现了方法层面的单一原则。

同理 类比到类上也一样, 或者说是不停的寻找最小单元。