重新组织函数
1、Extract Method （提炼函数）
动机：你有一段代码可以被组织在一起并独立出来。
做法：将这段代码放进一个独立函数中，并让函数名称解释该函数的用途。
如下面的实例，提炼后的代码变得更清晰易读。
代码1：
void printOwing(double previousAmount)){
Enumeration e = _orders.elemnets();
double outstanding = previousAmount * 1.2);
//pirnt banner
System.out.println("***************************");
System.out.println("****** Customer Owes ******");
System.out.println("***************************");
//calculate outstanding
while (e.hasMoreElements()) {
Order each = (Order)e.nextElement();
outstanding += each.getAmout();
}
//print details
System.out.print("name:" + _name);
System.out.print("amout:" + outstanding);
}
代码2：
void printOwing(double previousAmount){
printBanner();
double outstanding = getOutstanding(previousAmount * 1.2);
printDetails(outstanding);
}
void printBanner(){
System.out.println("***************************");
System.out.println("****** Customer Owes ******");
System.out.println("***************************");
}
double getOutstanding(double initialValue){
double result = initalValue;
Enumeration e = _orders.elemnets();
while (e.hasMoreElements()) {
Order each = (Order)e.nextElement();
result += each.getAmout();
}
return result;
}
void printDetails(double outstanding){
System.out.print("name:" + _name);
System.out.print("amout:" + outstanding);
}
2、Inline Method（内涵函数）
动机：一个函数的本体与名称同样清楚易懂。
做法：在函数调用点插入函数本体，然后移除该函数。
代码1：
int getRating(){
return (moreThanFiveLateDeliveries()) ? 2 : 1;
}
boolean moreThanFiveLateDeliveries(){
return _numberOfLateDeliveries > 5;
}
代码2：
int getRating(){
return (_numberOfLateDeliveries > 5) ? 2 : 1;
}
3、Inline Temp （内联临时变量）
动机：你有一个临时变量，只被一个简单表达式赋值一次，而它妨碍了其他重构手法。
做法：将所有对该变量的引用动作，替换为对它赋值的那个表达式自身。
备注：检查该变量是否真的被赋值一次，可以将该变量声明为final，然后编译。
代码1：
double basePrice = anOrder.basePrice();
return (basePrice > 1000);
代码2：
return (anOrder.basePrice()> 1000);
4、Replace Temp with Query（以查询取代临时变量）
动机：临时变量的问题在于：他们是暂时的，而且只能在所属函数内使用。由于临时变量只在所属函数内可见，所以他们会驱使你写更长的函数，因为只有这样你才能访问到需要的临时变量。如果把临时变量替换为一个查询，那么同一个类中的所有函数都将可以获得这份信心。这将带给你极大帮助，使你能够为这个类编写更清晰的代码。
做法：将这个表达式提炼到一个独立函数中。将这个临时变量的所有引用点替换为对新函数的调用。此后，新函数就可被其他函数使用。
代码1：
double basePrice = _quantity * _itemPrice;
if(basePrice > 1000)
reutrn basePrice * 0.95;
else
return basePrice * 0.98;
代码2：
if(basePrice() > 1000)
return basePrice() * 0.95;
else
return basePrice() * 0.98;
....
double basePrice(){
return _quantity * _itemPrice;
}
这个重构手法较为简单，如果临时变量比较多，还需要运用Split Temporary Variable（拆分临时变量）或Separate Query from Modifier（将查询函数和修改函数分离）使情况变得简单一些，然后再替换临时变量。如果你想替换的临时变量是用来收集结果的（例如循环中的累加值），就需要将某些程序逻辑（例如循环）复制到查询函数去。
代码1：
double getPrice(){
int basePrice = _quantity * _itemPrice;
double discountFactor;
if(basePrice > 1000) discountFactor = 0.95;
else discountFactor = 0.98;
return basePrice * discountFactor;
}
代码2：
double getPrice(){
return basePrice() * discountFactor();
}
private int basePrice(){
return _quantity * _itemPrice;
}
private double discountFactor(){
if(basePrice() > 1000) return 0.95;
else return 0.98;
}
5、Introduce Explaining Variable（引入解释性变量）
动机：你有一个复杂的表达式。在条件逻辑中，Introduce Explaining Variable 特别有价值：你可以用这项重构将每个条件子句提炼出来，以一个良好命名的临时变量来解释对应条件子句的意义。使用这项重构的另一种情况是，在较长算法中，可以运用临时变量来解释，每一步运算的意义。
代码1：
if((platform.toupperCase().indexOf("MAC") > -1) &&
(browser.toUpperCase().indexOf("IE") > -1) &&
wasInitialized() && resize > 0){
//do something
}
代码2：
final boolean isMacOs = platform.toupperCase().indexOf("MAC") > -1;
final boolean isIEBrowser = browser.toUpperCase().indexOf("IE") > -1;
final boolean wasResized = resize > 0;
if(isMacOs && isIEBrowser && wasResized){
//do something
}
类似的，我们也经常用Extract Method（提炼函数）来解释表达式用途，如下示例：
代码1：
double price(){
//price is base price - quantity discount + shipping
return _quantity * _itemPrice -
Math.max(0, _quantity - 500) * _itemPrice * 0.05 +
Math.min(_quantity * _itemPrice * 0.1, 100.0);
}
代码2：
double price(){
return basePrice() - quantityDiscount() + shipping();
}
private double quantityDiscount(){
return Math.max(0, _quantity - 500) * _itemPrice * 0.05;
}
private double shipping(){
return Math.min(basePrice() * 0.1, 100.0);
}
private double basePrice(){
return _quantity * _itemPrice;
}
Introduce Explaining Variable（引入解释性变量）和Extract Method（提炼函数）比较：两者都可以达到解释表达式的效果，我觉得主要看临时变量是否被公用到，如果不是，则用引入解释性变量即可。
6、Split Temporary Variable（分解临时变量）
场景：你的程序有某个临时变量被赋值超过一次，它既不是循环变量，也不被用于手机计算结果。
分析：这种临时变量应该制备赋值一次。如果它们被赋值超过一次，就意味它们在函数中承担了一个以上的责任。如果临时变量承担多个责任，它就应该被替换（分解）为多个临时变量，每个变量只承担一个责任。同一个临时变量承担两件不同的事情，会令代码阅读者糊涂。
代码1：
double temp = 2 * (_height + _width);
System.out.println(temp);
temp = _height * _width;
System.out.println"temp);
代码2：
final double perimeter = 2 * (_height + _width);
System.out.println(perimeter);
final double area = _height * _width;
System.out.println(area);
7、Remove Assignments to Parameters （移除对参数的赋值）
场景：代码对一个参数进行赋值。
做法：以一个临时变量取代该参数的位置。
分析：从本质上说，参数是对象的引用，而对象的引用时按值传递的。因此我可以修改参数对象的内部状态（属性），但对参数对象重新赋值是没有意义。
代码1：
int discount(int inputVal, int quantity, int yearToDate){
if(inputVal > 50) inputVal -=2;
}
代码2：
int discount(int inputVal, int quantity, int yearToDate){
int result = inputVal;
if(inputVal > 50) result -=2;
}
我还可以为参数加上关键词final，从而强制它遵循“不对参数赋值”这一惯例：
代码1：
int discount(int inputVal, int quantity, int yearToDate){
if(inputVal > 50) inputVal -=2;
if(quantity > 100) inputVal -=1;
if(yearToDate > 10000) inputVal -=4;
}
代码2：
int discount(final int inputVal, final int quantity, final int yearToDate){
int result = inputVal;
if(inputVal > 50) result -=2;
if(quantity > 100) result -=1;
if(yearToDate > 10000) result -=4;
}
不过我得承认，我不经常使用final来修饰参数，因为我发现，对于提高短函数的清晰度，这个方法并无太大帮助。我通常会在较长的函数中使用它，让它帮助我检查参数是否被做修改。
8、Replace Method with Method Object（以函数对象取代函数）
动机：你有一个大型函数，其中对局部变量的使用使你无法采用Extract Method（提炼函数）。
做法：将这个函数放进一个单独对象中，如此一来局部变量就成了对象内的字段。然后你可以在同一个对象中将这些大型函数分解为多个小型函数。
9、Subsitute Algorithm（替换算法）
动机：你需要把某个算法替换为另一个更清晰的算法。
做法：将函数本体替换为另一个算法。
代码1：
String foundPerson(String[] people){
for(int i=0; i<people.length; i++){
if(people[i].equals("Don")){
return "Don";
}
if(people[i].equals("John")){
return "John";
}
if(people[i].equals("Kent")){
return "Kent";
}
}
return "";
}
代码2：
String foundPerson(String[] people){
List candidates = Arrays.asList(new String[]{"Don", "John", "Kent");
for(int i=0; i<people.length; i++){
if(candidates.contains(people[i])){
return people[i];
}
}
return "";
}
