设计模式之------单一职责原则

基本介绍：一个类只负责一个职责。
实例解释：
违反单一职责的实例：

package com.yrz.singleresponsbility;  
/** 
 * ClassName:SingleResponsbility <br/> 
 * Function: TODO ADD FUNCTION. <br/> 
 * Reason:   TODO ADD REASON. <br/> 
 * Date:     2019年11月24日 下午11:00:33 <br/> 
 * @author   yrz
 * @version   
 * @since    JDK 1.6 
 * @see       
 */
public class SingleResponsbility1 {
	public static void main(String[] args) {
		Vehicle vehicle = new Vehicle();
		vehicle.run("汽车");
		vehicle.run("摩托车");
		vehicle.run("飞机");
	}
}
 
/**
 * 交通工具类
 * ClassName: Vehicle <br/> 
 * Function: TODO ADD FUNCTION. <br/> 
 * Reason: TODO ADD REASON(可选). <br/> 
 * date: 2019年11月24日 下午11:04:53 <br/> 
 * 
 * @author yrz
 * @version  
 * @since JDK 1.6
 */
class Vehicle{
	public void run(String vehicle) {
		System.out.println(vehicle + "在公路上行使");
	} 
}

console.log:
汽车在公路上行使
摩托车在公路上行使
飞机在公路上行使

分析：Vehicle的run方法做了三个具体交通工具的行驶方式，所以违反了单一职责原则。
解决思路：每一个交通工具run自己的行驶方式

/** 
 * Project Name:design-pattern 
 * File Name:SingleResponsbility.java 
 * Package Name:com.yrz.singleresponsbility 
 * Date:2019年11月24日下午11:00:33 
 * Copyright (c) 2019, [email protected] All Rights Reserved. 
 * 
*/

package com.yrz.singleresponsbility;

/**
 * ClassName:SingleResponsbility <br/>
 * Function: TODO ADD FUNCTION. <br/>
 * Reason: TODO ADD REASON. <br/>
 * Date: 2019年11月24日 下午11:00:33 <br/>
 * 
 * @author yrz
 * @version
 * @since JDK 1.6
 * @see
 */
public class SingleResponsbility2 {
	public static void main(String[] args) {
		CarVehicle carVehicle = new CarVehicle();
		carVehicle.run("汽车");
		MobileVehicle mobileVehicle = new MobileVehicle();
		mobileVehicle.run("摩托车");
		AirVehicle airVehicle = new AirVehicle();
		airVehicle.run("飞机");
	}
}

/**
 * 汽车 ClassName: CarVehicle <br/>
 * Function: TODO ADD FUNCTION. <br/>
 * Reason: TODO ADD REASON(可选). <br/>
 * date: 2019年11月24日 下午11:07:15 <br/>
 * 
 * @author yrz
 * @version
 * @since JDK 1.6
 */
class CarVehicle {
	public void run(String vehicle) {
		System.out.println(vehicle + "在公路上行使");
	}
}

/**
 * 摩托 ClassName: MobileVehicle <br/>
 * Function: TODO ADD FUNCTION. <br/>
 * Reason: TODO ADD REASON(可选). <br/>
 * date: 2019年11月24日 下午11:07:44 <br/>
 * 
 * @author yrz
 * @version CarVehicle
 * @since JDK 1.6
 */
class MobileVehicle {
	public void run(String vehicle) {
		System.out.println(vehicle + "在公路上行使");
	}
}

/**
 * 飞机 ClassName: AirVehicle <br/>
 * Function: TODO ADD FUNCTION. <br/>
 * Reason: TODO ADD REASON(可选). <br/>
 * date: 2019年11月24日 下午11:08:08 <br/>
 * 
 * @author yrz
 * @version CarVehicle.MobileVehicle
 * @since JDK 1.6
 */
class AirVehicle {
	public void run(String vehicle) {
		System.out.println(vehicle + "在公路上行使");
	}
}

分析：

1. 遵守单一职责。
2. 类分解，改动较大，同时客户端也需改造。
3. 能不能在公共交通类中，定义不同交通工具的行使方式，这样不仅可以实现具体交通工具的行使方式，也可以减少代码的书写。

/** 
 - Project Name:design-pattern 
 - File Name:SingleResponsbility.java 
 - Package Name:com.yrz.singleresponsbility 
 - Date:2019年11月24日下午11:00:33 
 - Copyright (c) 2019, [email protected] All Rights Reserved. 
 - 
*/  
  
package com.yrz.singleresponsbility;  
/** 
 - ClassName:SingleResponsbility <br/> 
 - Function: TODO ADD FUNCTION. <br/> 
 - Reason:   TODO ADD REASON. <br/> 
 - Date:     2019年11月24日 下午11:00:33 <br/> 
 - @author   yrz
 - @version   
 - @since    JDK 1.6 
 - @see       
 */
public class SingleResponsbility3 {
	public static void main(String[] args) {
		Vehicle2 vehicle = new Vehicle2();
		vehicle.carRun("汽车");
		vehicle.mobileRun("摩托车");
		vehicle.airRun("飞机");
	}
}
 
/**
 - 交通工具类
 - ClassName: Vehicle <br/> 
 - Function: TODO ADD FUNCTION. <br/> 
 - Reason: TODO ADD REASON(可选). <br/> 
 - date: 2019年11月24日 下午11:04:53 <br/> 
 - 
 - @author yrz
 - @version  
 - @since JDK 1.6
 */
class Vehicle2{
	public void carRun(String vehicle) {
		System.out.println(vehicle + "在公路上行使");
	} 
	
	public void mobileRun(String vehicle) {
		System.out.println(vehicle + "在公路上行使");
	} 
	
	public void airRun(String vehicle) {
		System.out.println(vehicle + "在公路上行使");
	} 
}

分析：

1. 这种修改方法没有对原来的类做大的修改，只是增加方法。
2. 这里虽然没有在类这个级别上遵守单一职责原则，但是在方法级别上，仍然是遵守单一职责

总结：

1. 降低类的复杂度，一个类只负责一项职责。
2. 提高类的可读性，可维护性。
3. 降低变更引起的风险。
4. 只有逻辑足够简单，才可以在代码级违反单一职责原则；只有类中方法数量足够少，可以在方法级别保持单一职责原则