2单一职责原则SRP

一、什么是单一职责原则

  单一职责原则(Single Responsibility Principle ): 就一个类而言,应该仅有一个引起它变化的 原因。

二、多功能的山寨手机

  山寨手机的功能: 拍照、摄像、手机游戏、网络摄像头、GPS、炒股 等等。

  功能多、但是每一个功能都不强。

  拍摄功能 ------>专业摄像机或照相机

  手机游戏 ------>PSP

  网络摄像头---->专业摄像头

  GPS功能------>专业GPS导航系统

三、烦人的山寨手机

  每一个职责都是一个变化的轴线,当需求变化 时会反映为类的职责的变化。如果一个类承担的 职责多于一个,那么引起它变化的原因就有多个。 一个职责的变化甚至可能会削弱或者抑制类完成 其他职责的能力,从而导致脆弱的设计。

四、单一职责原则示例

  接受客户端输入并提交到数据库。

  原有设计: 一个类负责接受客户端输入,对客户端输入进 行校验,连接数据库,并提交数据到数据库。

  现有设计: 一个功能也就是一个职责由一个类来负责。

原有设计:

 1 import java.util.Scanner;
 2
 3 public class SaveToDB {
 4     private String username;
 5     private String upassword;
 6
 7     //获得客户端输入
 8     public void shuru() {
 9         Scanner scanner = new Scanner(System.in);
10         System.out.println("请输入用户名");
11         username = scanner.nextLine();
12         System.out.println("请输入密码");
13         upassword = scanner.nextLine();
14     }
15
16     //进行数据校验
17     public boolean validate() {
18         if(username == null || "".equals(username.trim())) {
19             System.out.println("用户名不能为空");
20             return false;
21         }
22         if(upassword == null || "".equals(upassword.trim())) {
23             System.out.println("密码不能为空");
24             return false;
25         }
26         return true;
27     }
28
29     //连接数据库
30     public void getConnection() {
31         System.out.println("获得数据库连接");
32     }
33
34     //进行数据操作
35     public void save() {
36         System.out.println("将" + username + "保存到了数据库");
37         System.out.println("将" + upassword + "保存到了数据库");
38     }
39 }

测试

 1 public class MainClass {
 2     public static void main(String[] args) {
 3         //接受客户端的输入
 4         SaveToDB std = new SaveToDB();
 5         std.shuru();
 6         if(std.validate()) {
 7             std.getConnection();
 8             std.save();
 9         }
10     }
11 }

==========================================================================

现有设计:

客户端输入

 1 import java.util.Scanner;
 2
 3 public class Input {
 4     private String username;
 5     private String upassword;
 6
 7     //获得客户端输入
 8     public void shuru() {
 9         Scanner scanner = new Scanner(System.in);
10         System.out.println("请输入用户名");
11         username = scanner.nextLine();
12         System.out.println("请输入密码");
13         upassword = scanner.nextLine();
14     }
15
16     public String getUsername() {
17         return username;
18     }
19
20     public void setUsername(String username) {
21         this.username = username;
22     }
23
24     public String getUpassword() {
25         return upassword;
26     }
27
28     public void setUpassword(String upassword) {
29         this.upassword = upassword;
30     }
31 }

数据操作

1 public class DAOImp {
2     //进行数据操作
3     public void save(String username,String upassword) {
4         System.out.println("将" + username + "保存到了数据库");
5         System.out.println("将" + upassword + "保存到了数据库");
6     }
7 }

连接数据库

1 public class DBManager {
2     //连接数据库
3     public static void getConnection() {
4         System.out.println("获得数据库连接");
5     }
6 }

数据校验

 1 public class Validator {
 2     //进行数据校验
 3     public boolean validate(String username, String upassword) {
 4         if(username == null || "".equals(username.trim())) {
 5             System.out.println("用户名不能为空");
 6             return false;
 7         }
 8         if(upassword == null || "".equals(upassword.trim())) {
 9             System.out.println("密码不能为空");
10             return false;
11         }
12         return true;
13     }
14 }

测试

 1 public class MainClass {
 2     public static void main(String[] args) {
 3         Input input = new Input();
 4         input.shuru();
 5         Validator validator = new Validator();
 6         if(validator.validate(input.getUsername(), input.getUpassword())){
 7             DBManager.getConnection();
 8             DAOImp dao = new DAOImp();
 9             dao.save(input.getUsername(), input.getUpassword());
10         }
11     }
12 }

原文地址:https://www.cnblogs.com/justdoitba/p/9036460.html

时间: 2024-10-19 09:12:30

2单一职责原则SRP的相关文章

[OOD] 为什么单一职责原则(SRP)是最难运用的

单一职责原则(SRP)已经几乎是每一个程序员都知道的设计原则.最早由Robert C. Martin在<<敏捷软件开发 - 原则.模式与实践>>中正式提出.书中作者在结论中提到:  SRP是所有设计原则最简单的,但也是最难运用的.(中文翻译有之一,略去了) 现实工作中,关于一个类是否符合SRP,或者是否有必要符合SRP的讨论是经常发生的.争论的关键在于职责的定义,但我理解SRP真正的核心是关注于变化.这并不是我的新见解,全是来自Martin大叔的解释: 首先职责的定义是: 引起变化

Java 设计模式(十) 单一职责原则(SRP)

单一职责原则(Single Responsibility Principle) SRP 基本概念 单一职责原则 定义:应该有且仅有一个原因引起类的变更,也就是接口或类和职责的关系是一一对应的. 难点:职责的划分: 在不同情景和生产环境下我们对职责的细化是不同的(职责单一的相对性) 单一职责原则提出的是一个评价接口是否优良的标准,但是职责和变化原因是不可度量的,因项目而异,因环境而异(不可度量性) 优势: 类的复杂性降低:每个类或接口都只实现单一的职责,定义明确清晰 可读性提高:定义明确清晰,自然

架构师之路——单一职责原则SRP (我单纯,我快乐)

定义: 不要存在多于一个导致类变更的原因.通俗地讲,一个类只做一件事情. 单一职责原则的好处: 1.类的复杂性降低,实现什么职责都有清晰明确的定义: 2.可读性提高,复杂性降低,那当然可读性提高了: 3.可维护性提高,可读性提高,那当然更容易维护了: 4.变更引起的风险降低,变更是必不可少的,如果接口的单一职责做得好,一个接口修改只对相应的实现类有影响,对其他的接口无影响,这对系统的扩展性.维护性都有非常大的帮助. 建议: 接口一定要做到单一职责,类的设计尽量做到只有一个原因引起变化 SRP好处

敏捷开发:原则,模式与实践——第8章 单一职责原则SRP

鲍勃大叔说: 单一职责原则(SRP):就一个类而言,应该仅有一个引起它变化的原因. 我最开始理解成只能有一个原因去改变,跟我以前的认知有问题,从我开始学OOP以来,我觉得一个类就是一个事物的抽象,比如书,BOOK类,如果按照我理解的意思,book类就有很多可以改变它的原因,例如翻书或者买书,我感觉SRP说的是函数的职责,不是类的职责,于是我就去找了一个同学讨论,然后我们讨论了一会,得出的结论是这样的(以保龄球为例): SRP指的是只改变保龄球相关的内容算一件事,如果我用一个比赛类去代替保龄球的话

设计模式(3)-----单一职责原则

单一职责原则(SRP) 定义 就一个类而言,应该仅有一个引起它变化的原因.一个类,只有一个引起它变化的原因.应该只有一个职责.每一个职责都是变化的一个轴线,如果一个类有一个以上的职责,这些职责就耦合在了一起.这会导致脆弱的设计.当一个职责发生变化时,可能会影响其它的职责.另外,多个职责耦合在一起,会影响复用性.例如:要实现逻辑和界面的分离. 例子 例如在做一个根据参数对用户表进行查询再显示出来的功能,把这些东西写在一个类里面是非常不好的.如果一个类承担的职责过多,就等于把这些职责耦合在一起,一个

《大话设计模式》——单一职责原则

单一职责原则(SRP):就一个类而言,应该仅有一个能引起它变化的原因. 如果一个类承担的职责过多,就等于把这些职责耦合在一起,一个职责的变化可能会削弱或抑制这个类完成其他职责的能力.这种耦合会导致脆弱的设计,当变化发生时,设计会遭受到意想不到的破坏. 软件设计真正要做的许多内容,就是发现职责并把那些职责相互分离. 如果能想到多于一个的动机去改变一个类,那么这个类就具有多于一个的职责.就应该考虑类的职责分离.

(1)Single Responsibility Principle【单一职责原则】

单一职责原则 SRP:Single responsibility principle [概述]单一职责原则又称单一功能原则,面向对象五个基本原则(SOLID)之一.它规定一个类应该只有一个发生变化的原因.该原则由罗伯特·C·马丁(Robert C. Martin)于<敏捷软件开发:原则.模式和实践>一书中给出的.马丁表示此原则是基于汤姆·狄马克(Tom DeMarco)和Meilir Page-Jones的著作中的内聚性原则发展出的. 所谓职责是指类变化的原因.如果一个类有多于一个的动机被改变

第3章 单一职责原则

单一职责原则(SRP),就一个类而言,应该仅有一个引起它变化的原因. 如果一个类承担的职责过多,就等于把这些职责耦合在一起,一个职责的变化可能削弱或者抑制这个类完成其他职责的能力.这种耦合会导致脆弱的设计,当变化发生时,设计会遭受到意想不到的破坏. 软件设计真正要做的许多内容,就是发现职责并把哪些职责相互分离.如果你能够像到多于一个的动机去改变一个类,那么这个类就多于一个的职责,就应该考虑类的职责分离. 比如俄罗斯方块游戏,在移动端移植到PC端,可以将界面类和逻辑类分离,达到复用的目的. 第3章

敏捷软件开发 – SRP 单一职责原则

SRP:单一职责原则  一个类应该只有一个发生变化的原因. 为何把两个职责分离到单独的类中很重要呢?因为每一个职责都有变化的一个轴线.当需求变化时,该变化会反映为类的职责的变化.如果一个类承担了多于一个的职责,那么引起它变化的原因就会有多个. 如果一个类承担的职责过多,就等于把这些职责耦合在了一起.一个职责发生变化可能会削弱或抑制这个类完成其他职责的能力.这种耦合会导致脆弱的设计,当变化发生时,设计会遭受到意想不到的破坏. 有两个不同的应用程序使用Rectangle类.一个应用程序是有关计算几何