How to implement the single responsibility principle of java design pattern

Single Responsibility Principle (Single Responsibility Principle), referred to as SRP.

Definition:

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

There should be and only one reason for a class to change.

Sometimes, developers have some problems when designing interfaces. For example, user attributes and user behaviors are declared in an interface. This results in business objects and business logic being put together, which results in the interface having two responsibilities. The interface responsibilities are not clear. According to the definition of SRP, it violates the single responsibility principle of the interface.

The following is an example:

package com.loulijun.chapter1;     public interface Itutu {      //身高      void setShengao(double height);      double getShengao();      //体重      void setTizhong(double weight);      double getTizhong();      //吃饭      boolean chiFan(boolean hungry);      //上网      boolean shangWang(boolean silly);  }

The above example has this problem. Height and weight are business objects, and the corresponding methods are mainly responsible for the user's attributes. Eating and surfing the Internet are corresponding business logics, which are mainly responsible for user behavior. But this will give people the feeling of not knowing what this interface does, and the responsibilities are not clear, which will also cause various problems during later maintenance.

Solution: Single responsibility principle, just decompose this interface into two interfaces with different responsibilities

ItutuBO.java: Responsible for the attributes of tutu (Tutu, if it is a personal name)

package com.loulijun.chapter1;     /**   * BO：Bussiness Object，业务对象   * 负责用户的属性   * @author Administrator   *   */ public interface ItutuBO {      //身高      void setShengao(double height);      double getShengao();      //体重      void setTizhong(double weight);      double getTizhong();  }

ItutuBL.java: Responsible for Tutu’s behavior

package com.loulijun.chapter1;  /**   * BL:Business Logic,业务逻辑   * 负责用户的行为   * @author Administrator   *   */ public interface ItutuBL {      //吃饭      boolean chiFan(boolean hungry);      //上网      boolean shangWang(boolean silly);  }

This achieves the single responsibility of the interface. Then when implementing the interface, you need to have two different classes

TutuBO.java

package com.loulijun.chapter1;     public class TutuBO implements ItutuBO {      private double height;      private double weight;      @Override     public double getShengao() {                 return height;      }         @Override     public double getTizhong() {          return weight;      }         @Override     public void setShengao(double height) {          this.height = height;      }         @Override     public void setTizhong(double weight) {          this.weight = weight;      }     }

TutuBL.java

package com.loulijun.chapter1;     public class TutuBL implements ItutuBL {         @Override     public boolean chiFan(boolean hungry) {          if(hungry)          {              System.out.println("去吃火锅...");              return true;          }          return false;      }         @Override     public boolean shangWang(boolean silly) {          if(silly)          {              System.out.println("好无聊啊，上会网...");              return true;          }          return false;      }     }

This will make it clear that when user attributes need to be modified At this time, you only need to modify the ItutuBO interface, which will only affect the TutuBO class and not other classes.

So what is the significance of the single responsibility principle?

1. Reduce the complexity of the class and clearly define what responsibilities are implemented

2. Improve readability

3. Improve maintainability

4. Reduce the risks caused by changes, which is very helpful for system scalability and maintainability

However, there is a problem with using the single responsibility principle. There is no clear standard for dividing "responsibility". If the responsibilities are divided too finely, the number of interfaces and implementation classes will increase sharply, which will increase the complexity and reduce the reliability of the code. Maintainability. Therefore, when using this responsibility, specific circumstances must be analyzed. The suggestion is that the interface must adopt the single responsibility principle and implement the single responsibility principle as much as possible in the design of the class. The only reason is that a class changes.

The above is the detailed content of How to implement the single responsibility principle of java design pattern. For more information, please follow other related articles on the PHP Chinese website!