设计模式原则 - 单一职责原则（一）

我就是我 2023-09-23 19:19 144阅读 0赞

### 单一职责原则 ###

*  一 官方定义
 *   *  基本介绍
 *  二 案例演示
 *   *  普通方式实现
     *   *  解决方案
     *  解决方案一
     *   *  解决方案
         *  案例分析
     *  解决方案二
     *   *  解决方案
         *  案例分析
     *  案例总结
 *  三 注意事项&细节
 *  四 如何遵守单一职责原则？

# 一 官方定义 #

> 单一职责原则（Single Responsibility Principle, SRP），有且仅有一个原因引起类的变更

**顾名思义**：一个类只负责一项职责

## 基本介绍 ##

即对类来说，一个类应该只负责一项职责。如类 A 负责两个不同职责：职责 1，职责 2，当职责 1 需求变更而改变 A 时，可能造成职责 2 执行错误，所以需要将类 A 的粒度分解为 A1，A2  
![在这里插入图片描述][cc5de36d7a9043cf8b33b465b1bec044.png]

# 二 案例演示 #

> 需求：有一个动物类，里面定义一个在森林奔跑的方法，创建动物的实例，调用方法，方法内执行打印操作

## 普通方式实现 ##

### 解决方案 ###

/**
     * @Description 演示单一职责原则
     */
    public class SingleDemo {
        
        public static void main(String[] args) {
        
            new Animal().runForest("老虎");
            new Animal().runForest("狮子");
            new Animal().runForest("老鹰");
    
        }
    }
    
    //需求：有一个动物类，里面定义一个在森林奔跑的方法，创建动物的实例，调用方法，方法内执行打印操作
    class Animal {
        
        //森林奔跑的方法
        public void runForest(String animal) {
        
            System.out.println(animal + "在森林里愉快的奔跑");
        }
    }

**案例分析**  
![在这里插入图片描述][2938385696c24fb7baf0d310c2640bc9.png]  
语法上没有任何问题，但是在业务逻辑上有点不符合实际场景。老虎,狮子可以奔跑，老鹰应该是飞翔才对。这个run方法既有森林里奔跑的动物，又有天空中奔跑的动物，不仅违反了业务逻辑，又违反了单一职责。

## 解决方案一 ##

拆分类，拆分类为更小的粒度

### 解决方案 ###

1.  职责分解，将Animal类的职责分解成ForestAnimal类和AirAnimal类
2.  使用时分开使用对应的类

/**
     * @Description 演示单一职责原则
     */
    public class SingleDemo {
        
        public static void main(String[] args) {
        
            //方案一
            new ForestAnimal().run("老虎");
            new ForestAnimal().run("狮子");
            new ForestAnimal().run("老狼");
            new AirAnimal().fly("老鹰");
        }
    }
    //需求：有一个动物类，里面定义一个在森林奔跑的方法，创建动物的实例，调用方法，方法内执行打印操作
    class ForestAnimal{
        
        public void run(String animal){
        
            System.out.println(animal + "在森林里愉快的奔跑");
    
        }
    }
    class AirAnimal{
        
        public void fly(String animal){
        
            System.out.println(animal + "在天空中愉快的飞翔");
    
        }
    }

### 案例分析 ###

![在这里插入图片描述][b52474c5b79f49a8be26f057f87e1dff.png]  
优势：符合了业务逻辑，符合单一职责原则  
劣势：改动幅度大，不光是要拆分类，客户端的代码也要进行大幅度的改动

## 解决方案二 ##

直接在原来的类的基础上进行改动

### 解决方案 ###

/**
     * @Description 演示单一职责原则
     */
    public class SingleDemo {
        
        public static void main(String[] args) {
        
            new Animal().runForest("老虎");
            new Animal().runForest("狮子");
            new Animal().flyAir("老鹰");
        }
    }
    //需求：有一个动物类，里面定义一个在森林奔跑的方法，创建动物的实例，调用方法，方法内执行打印操作
    class Animal{
        
        //森林奔跑的方法
        public void runForest(String animal){
        
            System.out.println(animal + "在森林里愉快的奔跑");
    
        }
        //天空飞翔的方法
        public void flyAir(String animal){
        
            System.out.println(animal + "在天空里愉快的飞翔");
        }
    
    }

### 案例分析 ###

![在这里插入图片描述][15e6ab9eb82c456198b7cdbbff61767a.png]  
优势：改动幅度下，包括客户端，完成了业务逻辑  
劣势：是否违反单一职责原则？ （没有在类级别遵守单一职责，在方法级别的遵守）

## 案例总结 ##

**单一职责原则：各司其职**  
通过上面两种方案分析：  
方案一：类级别遵守了单一职责原则，但是改动的代价很高  
方案二：方法级别遵守了单一职责原则，改动幅度较小  
综上所述，单一职责原则最核心的什么？ 各司其职

# 三 注意事项&细节 #

1.  降低类的复杂度，一个类只负责一项职责

> 一个类职责少了，相应的复杂度不就低了嘛

1.  提高类的可读性以及可维护性

> 相应的复杂度降低了，代码量就会减少，可读性也就提高了，可维护性自然也就提高了

1.  降低变更引起的风险

> 一个类职责越多，变更的可能性就会越大，变化带来的风险就会越大

1.  通常情况下，我们应当遵守类级别单一职责原则

> 只有逻辑足够简单，才可以在代码中违反单一职责原则

# 四 如何遵守单一职责原则？ #

其实就是**合理的职责分解**，  
从业务出发，从需求出发，识别出同一个类型的职责  
需要说明一点：单一职责原则不是面向对象语言特有的，只要是模块化的程序设计，都要遵守单一职责原则

下一篇：[设计模式原则（二） - 接口隔离原则][-]

[cc5de36d7a9043cf8b33b465b1bec044.png]: https://img-blog.csdnimg.cn/cc5de36d7a9043cf8b33b465b1bec044.png
[2938385696c24fb7baf0d310c2640bc9.png]: https://img-blog.csdnimg.cn/2938385696c24fb7baf0d310c2640bc9.png
[b52474c5b79f49a8be26f057f87e1dff.png]: https://img-blog.csdnimg.cn/b52474c5b79f49a8be26f057f87e1dff.png
[15e6ab9eb82c456198b7cdbbff61767a.png]: https://img-blog.csdnimg.cn/15e6ab9eb82c456198b7cdbbff61767a.png
[-]: https://blog.csdn.net/weixin_43811057/article/details/128373526