【设计模式】七大原则之单一职责原则

一、设计模式的目的：

　　编写软件过程中，程序员面临来自耦合性，内聚性，可维护性，可扩展性，重用性，灵活性等多方面的挑战，设计模式是为了让程序（软件），具有更好的：

1. 代码重用性 （即：相同功能的代码，不用多次编写）

2. 可读性 （即：编程规范性, 便于其他程序员的阅读和理解）

3. 可扩展性 （即：当需要增加新的功能时，非常的方便，称为可维护）

4.  可靠性 （即：当我们增加新的功能后，对原来的功能没有影响）

5. 使程序呈现高内聚，低耦合的特性

　　分享金句:

• 设计模式包含了面向对象的精髓，“懂了设计模式，你就懂了面向对象分析和设计(OOA/D)的精要”

• Scott Mayers 在其巨著《Effective C++》就曾经说过:C++老手和 C++新手的区别就是前者手背上有很多伤疤

二、设计模式七大原则：

　　设计模式原则，其实就是程序员在编程时，应当遵守的原则，也是各种设计模式的基础（即：设计模式为什么这样设计的依据）　　

　　设计模式常用的七大原则有:

• 单一职责原则

• 接口隔离原则

• 依赖倒转(倒置)原则

• 里氏替换原则

• 开闭原则

• 迪米特法则

• 合成复用原则

　　本篇讲解单一职责原则，其他原则会在以后的博文中讲解。

三、单一职责原则

　　基本介绍：

　　对类来说的，即一个类应该只负责一项职责。

　　违反单一职责原则的坏处：如类 A 负责两个不同职责:职责 1，职责 2。当职责 1 需求变更而改变类 A 时，可能造成职责 2 执行错误，所以需要将类 A 的粒度分解为 A1，A2（即遵循单一职责原则）

　　该原则提出对象不应该承担太多职责，如果一个对象承担了太多的职责，至少存在以下两个缺点：

1. 一个职责的变化可能会削弱或者抑制这个类实现其他职责的能力

2. 当客户端需要该对象的某一个职责时，不得不将其他不需要的职责全都包含进来，从而造成冗余代码或代码的浪费

方案一代码示例：

package com.atguigu.principle.singleresponsibility; 
 
public class SingleResponsibility1 {
 
    public static void main(String[] args) {
        Vehicle vehicle = new Vehicle(); 
        vehicle.run("摩托车"); 
        vehicle.run("汽车");
        // 改进之前，传入飞机时输出结果：飞机在公路上运行；这样程序明显是不对的
        // 所以改进方式就是新增一个fly方法，让飞机在天上飞
        // 但是这样就违背了类的单一职责原则，因为交通工具类有了多个职责，又负责跑，又负责飞
        // vehicle.run("飞机");
        vehicle.fly("飞机");
    } 
}
 
// 交通工具类
// 方式 1
// 1. 在方式 1 中的 fly 方法，违反了单一职责原则
// 2. 解决的方案非常的简单，根据交通工具运行方法不同，分解成不同类即可 
class Vehicle {
    public void run(String vehicle) { 
        System.out.println(vehicle + " 在公路上跑....");
    }
 
    // 改进后保证程序正确但是类违反单一职责原则
    public void fly(String vehicle) { 
        System.out.println(vehicle + " 在天空上飞....");
    }
}

方案二代码示例：

package com.atguigu.principle.singleresponsibility; 
 
public class SingleResponsibility2 {
 
    public static void main(String[] args) {
        RoadVehicle roadVehicle = new RoadVehicle(); 
        roadVehicle.run("摩托车");
        roadVehicle.run("汽车");
        AirVehicle airVehicle = new AirVehicle();
        airVehicle.fly("飞机");
        WaterVehicle waterVehicle = new WaterVehicle();
        waterVehicle.swim("轮船");
    }
}
 
//方案 2 的分析
//1. 遵守单一职责原则
//2. 但是这样做的改动很大，即将类分解，同时修改客户端 
//3. 改进:直接修改 Vehicle 类，改动的代码会比较少=>方案 3
class RoadVehicle {
 
    public void run(String vehicle) {
        System.out.println(vehicle + "在公路上跑...."); 
    }
}
 
class AirVehicle {
 
    public void fly(String vehicle) {
        System.out.println(vehicle + "在天空上飞...."); 
    }
}
 
class WaterVehicle {
 
    public void swim(String vehicle) {
        System.out.println(vehicle + "在大海中游...."); 
    }
}

方案三代码示例：

package com.atguigu.principle.singleresponsibility; 
 
public class SingleResponsibility3 {
 
    public static void main(String[] args) { 
        Vehicle2 vehicle2 = new Vehicle2(); 
        vehicle2.run("汽车");
        vehicle2.fly("轮船");
        vehicle2.swim("飞机");
    } 
}
 
//方式 3 的分析
//1. 这种修改方法没有对原来的类做大的修改，只是增加方法
//2. 这里虽然没有在类这个级别上遵守单一职责原则，但是在方法级别上，仍然是遵守单一职责 
class Vehicle2 {
 
    public void run(String vehicle) {
        System.out.println(vehicle + " 在公路上跑...."); 
    }
 
    public void fly(String vehicle) { 
        System.out.println(vehicle + " 在天空上飞....");
    }
 
    public void swim(String vehicle) { 
        System.out.println(vehicle + " 在大海中游....");
    }
//方法 2. 
//..
//..
//..
}

个人觉得比较好的例子：

　　大学学生工作管理程序：

　　分析：大学学生工作主要包括学生生活辅导和学生学业指导两个方面的工作，其中生活辅导主要包括班委建设、出勤统计、心理辅导、费用催缴、班级管理等工作，学业指导主要包括专业引导、学习辅导、科研指导、学习总结等工作。如果将这些工作交给一位老师负责显然不合理，正确的做法是生活辅导由辅导员负责，学业指导由学业导师负责，其类图如图 1 所示，也即不同的职责找不同的类，类的单一职责。

　　

　　注意：单一职责同样也适用于方法。一个方法应该尽可能做好一件事情。如果一个方法处理的事情太多，其颗粒度会变得很粗，不利于重用。

四、单一职责原则注意事项和细节

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

2. 提高类的可读性，可维护性

3. 降低变更引起的风险

4. 通常情况下，我们应当遵守单一职责原则，只有逻辑足够简单，才可以在代码级违反单一职责原则；只有类中方法数量足够少，可以在方法级别保持单一职责原则

原文链接：https://blog.csdn.net/qq784515681/article/details/105110527

 参考：http://c.biancheng.net/view/1327.html