一、单一职责原则简介

---

单一职责原则 : 不要存在 多余一个 导致 类变更的原因 ;

假设有一个类 , 负责 $2$ 个职责 , 职责 $1$ 和 职责 $2$ ;
一旦 需求发生变更 , 如 职责 $1$ 相关功能发生改变 ;
修改该类的 职责 $1$ 功能时 , 有可能导致原本运行正常的职责 $2$ 发生故障 ;

对于上述类 , 应该 分别针对 职责 $1$ 和 职责 $2$ , 各自建立一个独立的类 , 这样就保证了系统的稳定性 ;
这样修改 职责 $1$ 和 职责 $2$ 中的任何一个功能 , 都不会影响另外一个职责的功能 ;

推荐的开发方法 : 使一个 类 / 接口 / 方法 只负责一项职责 ;

单一职责优点 : 提高 类的 可读性 , 提高 系统的 可维护性 , 降低 类的复杂度 , 降低 变更引起的风险 ;

类越简单 , 可读性越好 , 同时提高了可维护性 ;
一个类只负责一个职责 , 比负责多个职责 , 类要 简单得多 ;
变更是必然的 , 必须要接收变更 , 如果 单一职责原则遵守的好 , 当修改一个功能时 , 可以 显著降低对其它功能的影响 ;

单一职责原则 不只是 面向对象 设计中特有的职责 , 只要是模块化的系统 , 都适合使用单一职责原则 ;

二、单一职责原则代码示例 ( 反面示例 )

---

1、不遵循单一职责原则的类

Bird 类 , 代表了所有的鸟类 , 主要的移动方式是 用翅膀飞 , 和 用脚走 ;

如果要加入新的鸟 企鹅 , 就需要修改该类的代码 , 在 if … else … 上添加新的分支 , 一旦修改 , 就会导致当前类存在潜在风险 , 影响其它的功能 ;

package singleresponsibility;

public class Bird {
    public void mainMoveMode(String name) {
        if ("鸵鸟".equals(name)) {
            System.out.println(name + " 用翅膀飞");
        } else {
            System.out.println(name + " 用脚走");
        }
    }
}

2、测试类

package singleresponsibility;

public class Main {
    public static void main(String[] args) {
        Bird bird = new Bird();
        bird.mainMoveMode("大雁");
        bird.mainMoveMode("鸵鸟");
    }
}

执行结果 :

大雁 用脚走
鸵鸟 用翅膀飞

三、单一职责原则代码示例 ( 正面示例 | 类的单一职责 )

---

上面反面示例中 , Bird 类承担了 $2$ 个职责 , 用翅膀飞的鸟 和 用脚走的鸟 的职责都在一个类中实现 , 这就导致了一旦修改一个职责 , 另外一个也有可能被影响 ;

1、用翅膀飞的鸟

package singleresponsibility;

/**
 * 用翅膀飞的鸟
 *      本类的职责单一 , 只负责用翅膀飞的鸟的移动
 */
public class FlyBird {
    public void mainMoveMode(String name) {
        System.out.println(name + " 用翅膀飞");
    }
}

2、用脚走的鸟

package singleresponsibility;

/**
 * 用脚走路的鸟
 *      本类的职责单一 , 只负责用脚走的鸟的移动
 */
public class WalkBird {
    public void mainMoveMode(String name) {
        System.out.println(name + " 用脚走");
    }
}

3、测试类

package singleresponsibility;

public class Main {
    public static void main(String[] args) {

        FlyBird flyBird = new FlyBird();
        flyBird.mainMoveMode("大雁");

        WalkBird walkBird = new WalkBird();
        walkBird.mainMoveMode("鸵鸟");
    }
}

执行结果 :

大雁 用脚走
鸵鸟 用翅膀飞

四、单一职责原则代码示例 ( 接口的单一职责 )

---

1、反面示例

该 IGood 接口负责两大块职责 , 获取商品信息 获取 名称 / 价格 , 管理商品 购买 / 退款 ;

这个接口设计 , 违背了单一职责原则 ;

package singleresponsibility;

/**
 * 该接口负责两大块职责
 *      获取商品信息 获取 名称 / 价格
 *      管理商品 购买 / 退款
 * 这样就违背了单一职责原则
 */
public interface IGood {
    /**
     * 获取商品名称
     * @return
     */
    String getName();

    /**
     * 获取价格
     * @return
     */
    double getPrice();

    /**
     * 购买商品
     */
    void buyGood();

    /**
     * 退款
     */
    void refund();
}

2、拆分出的接口 1

package singleresponsibility;

/**
 * 信息管理
 *      该接口负责 获取商品信息 获取 名称 / 价格
 */
public interface IGoodInfo {
    /**
     * 获取商品名称
     * @return
     */
    String getName();

    /**
     * 获取价格
     * @return
     */
    double getPrice();
}

3、拆分出的接口 2

package singleresponsibility;

/**
 * 商品管理
 *      负责商品的 购买 / 退款
 */
public interface IGoodManager {
    /**
     * 购买商品
     */
    void buyGood();

    /**
     * 退款
     */
    void refund();
}

4、接口实现类

package singleresponsibility;

/**
 * 商品实现类
 *      同时实现 IGoodManager 和 IGoodInfo 两个接口
 */
public class GoodImpl implements IGoodManager, IGoodInfo{
    @Override
    public String getName() {
        return null;
    }

    @Override
    public double getPrice() {
        return 0;
    }

    @Override
    public void buyGood() {

    }

    @Override
    public void refund() {

    }
}

五、单一职责原则代码示例 ( 方法的单一职责 )

---

如果一个方法中 , 存在了 大块的 if … else … 判定 , 说明应该将其拆分成两个不同的方法 ;

1、反面示例

package singleresponsibility;

public class Good {
    /**
     * 更新商品的 名称 和 价格信息
     *      该方法的职责就不是单一职责的
     *      如果要针对 价格 信息修改策略进行修改
     *      会连带这 另外一个 职责 修改名称 , 也存了未知风险
     * @param name
     * @param price
     */
    public void updateGoodInfo(String name, double price) {
    }
}

2、单一职责示例

package singleresponsibility;

public class Good {
    /**
     * 更新商品的名称
     * @param name
     */
    public void updateGoodName(String name) {
    }

    /**
     * 更新商品的价格
     * @param price
     */
    public void updateGoodPrice(double price) {
    }
}