重构笔记——移除对参数的赋值

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/pistolove/article/details/42497857

本文是在学习中的总结,欢迎转载但请注明出处:http://blog.csdn.net/pistolove/article/details/42497857


        在上一篇文章中介绍了“分解临时变值“。本文将介绍“移除对参数的赋值”这种重构手法。

        下面让我们来学习这种重构手法吧。


开门见山

        发现:代码对一个参数进行赋值。

        解决:以一个临时变量取代该参数的位置。

	//重构前
	int dicount(int inputVal, int quantity, int yearToDate){
		if(inputVal > 50) inputVal-=10;
	}
	//重构后
	int dicount(final int inputVal, int quantity, int yearToDate){
		int result = inputVal;
		if(result > 50) result-=10;
	}


动机

        我想你很清楚“对参数赋值”这个说话的意思。如果把一个名称为fool的对象作为参数传递给某个函数,那么“对参数赋值”意味改变fool,使它引用另一个对象。但是,如果在“被传入对象”身上进行什么操作,那没问题,我们经常会这么做。这里只针对“fool被改变而指向另一个对象”这种情况来讨论:

void test(Object fool){
	fool.changedBySomeWay(); //that's ok
	fool=anotherObject; //trouble will appear
}
        我们之所不这样做,是因为它降低了代码的清晰度,而且混用了按值传递和按引用传递这两种参数传递方式。JAVA只采用按值进行传递。

        在按值传递的情况下,对参数的任何修改,都不会对调用端造成任何影响。如果你只以参数表示“被传递进来的东西”,那么代码会清晰的多,因为这种用法在所有语言中都表现出相同的语义。

        在JAVA中,一般不要对参数赋值:如果你看到手上的代码已经这么做了,就应该使用本文的方法。



做法

(1)建立一个临时变量,把待处理的参数值赋赋予它。
(2)以“对参数的赋值”为界,将其后所有对此参数的引用点,全部替换为“对此临时变量的引用”。
(3)修改赋值语句,使其改为对新建之临时变量赋值。
(4)编译,测试。
(如果代码的语义是按照引用传递的,需在调用端检查调用后是否还使用了这个参数。也要检查有多少个按引用传递的参数被赋值后又被使用。应该尽量以return方式返回一个值。如果返回值有多个,可考虑将需返回的一大堆数据变为对象,或者为每个返回值设定一个独立的函数)


示例

        我们从一个简单代码开始:
	int dicount(int inputVal, int quantity, int yearToDate){
		if(inputVal > 50) inputVal-=5;
		if(quantity > 100) quantity-=10;
		if(yearToDate > 1000) yearToDate-=100;
		return inputVal;
	}
        以临时变量取代对参数的赋值动作,得到下列代码:
	int dicount(int inputVal, int quantity, int yearToDate){
		int result  = inputVal;
		if(result > 50) result-=5;
		if(quantity > 100) quantity-=10;
		if(yearToDate > 1000) yearToDate-=100;
		return result;
	}
        可以为参数加上final关键词,强制其遵循“不对参数赋值”这一惯例:
	int dicount(final int inputVal, final int quantity, final int yearToDate){
		int result  = inputVal;
		if(result > 50) result-=5;
		if(quantity > 100) quantity-=10;
		if(yearToDate > 1000) yearToDate-=100;
		return result;
	}


JAVA的按值传递

        我们应该都知道,JAVA使用按值传递的函数调用方式,这常常也会使大家迷惑。在所有地点,JAVA都会遵循严格按值传递:

	//JAVA按值的传递
	class Params{
		public static void main(String[] args) {
			int x = 10;
			triple(x);
			System.err.println("x after triple:" + x);
		}
		
		private static void triple(int arg){
			arg = arg * 3;
			System.err.println("arg in triple:" +arg );
		}
	}
	//输出
	//arg in triple:30 
	//x after triple:10
        上面代码是使用基本数据类型进参数传递,还不至于让人糊涂。但如果参数中传递的是对象,就可能把人弄糊涂。如果在程序中以Date对象表示日期,下列程序所示:

//以对象为参数
class Params{
	public static void main(String[] args) {
		Date d1 = new Date(2015,1,1);
		nextDateUpdate(d1);
		System.err.println("d1 after nextday:" + d1);
		
		Date d2 = new Date(2015,1,1);
		nextDateReplace(d2);
		System.err.println("d2 after nextday:" + d2);//61380864000000
		
	}

	private static void nextDateUpdate(Date d) {
		d.setDate(d.getDate()+1);
		System.err.println("arg in nextday d1 : "+d);
	}

	private static void nextDateReplace(Date d) {
		d = new Date(d.getYear(),d.getMonth(),d.getDate()+1);
		d=null;
		System.err.println("arg in nextday d2: "+d);
	}
}

//输出
/*
 arg in nextday d1 : Tue Feb 02 00:00:00 CST 3915
 d1 after nextday:   Tue Feb 02 00:00:00 CST 3915
 arg in nextday d2:  Tue Feb 02 00:00:00 CST 3915
 d2 after nextday:   Mon Feb 01 00:00:00 CST 3915
 */
        从本质上说,对象的引用是按值传递的。因为可以修改参数对象的内部状态,但对参数对象重新赋值是没有意义的。

        本文主要介绍了重构手法——移除对参数的赋值。我觉得这个重构手法使用的情况并不常见,一般情况下,我们都觉得没有必要把参数的值重新定义。但是为了让代码显得比较清晰,在某些情况下还是值得做的。
        最后,希望本文对你有所帮助。有问题可以留言,谢谢。(PS:下一篇将介绍重构笔记——以函数对象取代函数)


重构笔记文章如下

       重构笔记——入门篇

       重构笔记——代码的坏味道(上

       重构笔记——代码的坏味道(下)

       重构笔记——构筑测试体

       重构笔记——提炼函数

       重构笔记——内联函数

       重构笔记——内联临时变量

       重构笔记——以查询取代临时变量

       重构笔记——引入解释性变量

       重构笔记——分解临时变量


没有更多推荐了,返回首页

私密
私密原因:
请选择设置私密原因
  • 广告
  • 抄袭
  • 版权
  • 政治
  • 色情
  • 无意义
  • 其他
其他原因:
120
出错啦
系统繁忙,请稍后再试