设计模式6大原则:单一职责原则

单一职责原则(Single Responsibility Principle),简称SRP。

定义:

There should never be more than one reason for a class to change.

应该有且仅有一个原因引起类的变更。

有时候,开发人员设计接口的时候会有些问题,比如用户的属性和用户的行为被放在一个接口中声明。这就造成了业务对象和业务逻辑被放在了一起,这样就造成了这个接口有两种职责,接口职责不明确,按照SRP的定义就违背了接口的单一职责原则了。

下面是个例子:

 
 
 
  1. package com.loulijun.chapter1;
  2.  
  3. public interface Itutu {
  4.     //身高
  5.     void setShengao(double height);
  6.     double getShengao();
  7.     //体重
  8.     void setTizhong(double weight);
  9.     double getTizhong();
  10.     //吃饭
  11.     boolean chiFan(boolean hungry);
  12.     //上网
  13.     boolean shangWang(boolean silly);
  14. }

上面的例子就存在这个问题,身高、体重属于业务对象,与之相应的方法主要负责用户的属性。而吃饭、上网是相应的业务逻辑,主要负责用户的行为。但是这就会给人一种不知道这个接口到底是做什么的感觉,职责不清晰,后期维护的时候也会造成各种各样的问题。

解决办法:单一职责原则,将这个接口分解成两个职责不同的接口即可

ItutuBO.java:负责tutu(涂涂,假如是个人名)的属性

 
 
 
  1. package com.loulijun.chapter1;
  2.  
  3. /**
  4.  * BO:Bussiness Object,业务对象
  5.  * 负责用户的属性
  6.  * @author Administrator
  7.  *
  8.  */
  9. public interface ItutuBO {
  10.     //身高
  11.     void setShengao(double height);
  12.     double getShengao();
  13.     //体重
  14.     void setTizhong(double weight);
  15.     double getTizhong();
  16. }

ItutuBL.java:负责涂涂的行为

 
 
 
  1. package com.loulijun.chapter1;
  2. /**
  3.  * BL:Business Logic,业务逻辑
  4.  * 负责用户的行为
  5.  * @author Administrator
  6.  *
  7.  */
  8. public interface ItutuBL {
  9.     //吃饭
  10.     boolean chiFan(boolean hungry);
  11.     //上网
  12.     boolean shangWang(boolean silly);
  13. }

这样就实现了接口的单一职责。那么实现接口的时候,就需要有两个不同的类

TutuBO.java

 
 
 
  1. package com.loulijun.chapter1;
  2.  
  3. public class TutuBO implements ItutuBO {
  4.     private double height;
  5.     private double weight;
  6.     @Override
  7.     public double getShengao() {       
  8.         return height;
  9.     }
  10.  
  11.     @Override
  12.     public double getTizhong() {
  13.         return weight;
  14.     }
  15.  
  16.     @Override
  17.     public void setShengao(double height) {
  18.         this.height = height;
  19.     }
  20.  
  21.     @Override
  22.     public void setTizhong(double weight) {
  23.         this.weight = weight;
  24.     }
  25.  
  26. }

TutuBL.java

 
 
 
  1. package com.loulijun.chapter1;
  2.  
  3. public class TutuBL implements ItutuBL {
  4.  
  5.     @Override
  6.     public boolean chiFan(boolean hungry) {
  7.         if(hungry)
  8.         {
  9.             System.out.println("去吃火锅...");
  10.             return true;
  11.         }
  12.         return false;
  13.     }
  14.  
  15.     @Override
  16.     public boolean shangWang(boolean silly) {
  17.         if(silly)
  18.         {
  19.             System.out.println("好无聊啊,上会网...");
  20.             return true;
  21.         }
  22.         return false;
  23.     }
  24.  
  25. }

这样就清晰了,当需要修改用户属性的时候只需要对ItutuBO这个接口来修改,只会影响到TutuBO这个类,不会影响其他类。

那么单一职责原则的意义何在呢?

  1. 降低类的复杂性,实现什么样的职责都有清晰的定义
  2. 提高可读性
  3. 提高可维护性
  4. 降低变更引起的风险,对系统扩展性和维护性很有帮助

但是、使用单一职责原则有一个问题,“职责”没有一个明确的划分标准,如果把职责划分的太细的话会导致接口和实现类的数量剧增,反而提高了复杂度,降低了代码的可维护性。所以使用这个职责的时候还要具体情况具体分析。建议就是接口一定要采用单一职责原则,实现类的设计上尽可能做到单一职责原则,***是一个原因引起一个类的变化。

网页名称:设计模式6大原则:单一职责原则
网页地址:http://www.shufengxianlan.com/qtweb/news11/383511.html

网站建设、网络推广公司-创新互联,是专注品牌与效果的网站制作,网络营销seo公司;服务项目有等

广告

声明:本网站发布的内容(图片、视频和文字)以用户投稿、用户转载内容为主,如果涉及侵权请尽快告知,我们将会在第一时间删除。文章观点不代表本网站立场,如需处理请联系客服。电话:028-86922220;邮箱:631063699@qq.com。内容未经允许不得转载,或转载时需注明来源: 创新互联