2007-09-26

重构之临时变量(Replace Temp with Query)

当你的程序以一个临时变量保存某一表达式的运算结果

将这个表达式提炼到一个独立函数中，将这个临时变量的所有［被引用点］替换为［对新函数的调用］，新函数可被其他函数使用

java 代码
  1. double  basePrice=_quantity * _itemPrice;
  2. if(basePrice>1000){
  3.      return basePrice * 0.95;
  4. else
  5.      return basePrice * 0.38;
  6. }
  7. ......

 

提炼后：

java 代码
  1. if (basePrice()>1000){
        return basePrice() * 0.95
  2. else
  3.     return basePrice() * 0.38
  4. }
  5. ......
  6. double basePrice(){
  7.     return _quantity * _itemPrice;
    }

动机：
临时变量的问题在于：它们是暂时的，而且只能在所属函数内使用，由于临时变量只有在所属内才可见，所以它们会驱使你写出更长的函数，因为只有这样你才能访问到想要访问的临时变量，如果把临时变量替换为一个查询式（query method），那么同一个CLASS中的所有函数都将获得这份信息。这将带给你极大帮助，使你能够为这个CLASS编写更清晰的代码。

这个重构手法较为直率的情况就是：临时变量只被赋值一次，或者赋值给临时变量的表达式不受其他条件影响，其他情况比较情况棘手，但也有可能发生，你可能需要先运用Split Temporary Variable 或Separate Query from Modifier 使情况变得简单一些。如果你想替换的临时变量是用来收集结果的（例如循环中的累加值），你就需要将某些程序的逻辑（例如循环）拷贝到查询式（query method）去。


作法：

  • 找出只被赋值一次的临时变量
  • 将临时变量声明为 final
  • 编译（这可确保临时变量的确只被赋值一次）
  • 将对该临时变量赋值之语句的等号右侧部分提炼到一个独立函数中。详细步骤：首先将函数声明为private，之后你可能会发现有更多CLASS需要使用它，彼时你可轻易放松对它的保护。确保提炼出来的函数无任何连带影响，就对它进行Separate Query from Modifier
  • 编译，测试

 范例：
首先，我从一个简单函数开始：

java 代码
  1. double  getPrice()
  2. {   
  3.      int basePrice=_quantity+_itemPrice;   
  4.      double discountFactor;   
  5.      if(basePrice>1000)   
  6.         discountFactor=0.95;   
  7.      else  
  8.         discountFactor=0.98;   
  9.      return  basePrice = discountFactor;   
  10.    
  11. }  

 我希望将这个两个变量都替换掉，当然，每次一个。

尽管这里的代码十分清楚，我还是先把临时变量声明为final，检查它们是否的确只被赋值一次：

java 代码
  1. double getPrice()   
  2. {   
  3.       final int basePrice = _quantity * _itemPrice;   
  4.       final double discountFactor;   
  5.       if(basePrice>1000)   
  6.          discountFactor=0.95;   
  7.       else  
  8.          discountFactory=0.98;   
  9.       return basePrice * discountFactor;   
  10. }  

这么一来，如果有任何问题，编译器就会警告我，之所以先做这件事，因为如果临时变量不只被赋值一次，不该进行这项重构了，接下来我开始替换临时变量了，每次一个，首先我把赋值动作的右侧表达式提炼出来。

java 代码
  1. double getPrice()   
  2. {   
  3.       final int basePrice = basePrice();   
  4.       final double discountFactor;   
  5.       if(basePrice >1000)   
  6.          discountFactor =0.95;   
  7.       else  
  8.          discountFactor =0.98;   
  9.       return basePrice * discountFactor;   
  10. }   
  11. private int basePrice()   
  12. {   
  13.       return _quantity * _itemPrice;   
  14. }   
  15.     

再把临时变量的引用点替换掉：

java 代码
  1. double getPrice()   
  2. {   
  3.     final int basePrice = basePrice();   
  4.     final double discountFactor;   
  5.     if ( basePrice()>1000 )   
  6.        discountFactor = 0.95;   
  7.     else  
  8.        discountFactor = 0.98;   
  9.    return basePrice() * discountFactor;   
  10. }  

下一步：

java 代码
  1. double getPrice()      
  2. {      
  3.     final double discountFactor;      
  4.     if ( basePrice()>1000 )      
  5.        discountFactor = 0.95;      
  6.     else     
  7.        discountFactor = 0.98;      
  8.    return basePrice() * discountFactor;      
  9. }    

下一步（仔细观察代码）

java 代码
  1. double getPrice()      
  2. {      
  3.    return basePrice() * discountFactor();      
  4. }     
  5.   
  6. private double discountFactor()   
  7. {   
  8.     if ( basePrice()>1000 )      
  9.        return  0.95;      
  10.     else     
  11.        return  0.98;      
  12. }   
  13.   
  14. private int basePrice()   
  15. {   
  16.     return _quantity * _itemPrice;   
  17. }  

是多么简单啊(代码有错请指点）

 

评论
dongsj8325@sohu.com 2007-10-16
貌似连代码都没改,用自己的理解写一段会比较好
eivenchan 2007-10-16
似乎是《重构》一书中的内容？
发表评论

提醒: 该博客已发表在公共论坛，博客所有留言会成为论坛回贴，留言请注意遵守论坛发贴规则

您还没有登录，请登录后发表评论

liuzongan
搜索本博客
我的相册
C8ce1301-f7c2-31ae-9f75-a3294b094bc2-thumb
李1翠
共 6 张
最近加入圈子
存档
最新评论