重构研究：Replace Method with Method Object(用方法对象代替方法)

动机：

如果一个函数的局部变量数量很多，那么分解这个函数是很困难的。虽然可以使用Replace Temp with Query(用查询函数代替临时变量)可以减少临时变量，但是有时候你发现无法拆解时，就要用到此方法

做法：

1.建立一个新类，根据要处理的函数的功能命名

2.如果有用到源对象中的函数，就要建立一个final字段，类型为源对象

3.把源函数中的临时变量，变为类的变量，建立构造函数，把源函数的临时变量传递进来

4.建立一个compute()函数

5.把源函数的内容拷贝到compute()函数中，如果有用到源函数中的其他函数调用，请使用第2步创建的源对象来调用

6.将旧函数的调用改为：创建一个新类对象，然后再调用新类对象的compute()函数

现在因为临时变量已经变成实例变量，就可以在新类的compute()函数中任意拆分了

举个例子： 

public class Account {

    private int gamma(int inputVal, int quantity, int yearToDate) {
        int importantValue1 = (inputVal * quantity) + dalta();
        int importantValue2 = (inputVal * yearToDate) + 100;
        if ((yearToDate - importantValue1) > 100) {
            importantValue2 -= 20;
        }
        int importantValue3 = importantValue2 * 7;

        return importantValue3 - 2 * importantValue1;
    }
}

 修改完后的代码如下：

public class Account {

    private int gamma(int inputVal, int quantity, int yearToDate) {
        return new Gamma(this, inputVal, quantity, yearToDate).compute();
    }
}

class Gamma {
    private final Account account;
    private int inputVal;
    private int quantity;
    private int yearToDate;

    public Gamma(Account source, int inputValArg, int quantityArg,
            int yearToDateArg) {
        this.account = source;
        this.inputVal = inputValArg;
        this.quantity = quantityArg;
        this.yearToDate = yearToDateArg;
    }
    
    public int compute() {
        int importantValue1 = (inputVal * quantity) + this.account.dalta();
        int importantValue2 = (inputVal * yearToDate) + 100;
        if ((yearToDate - importantValue1) > 100) {
            importantValue2 -= 20;
        }
        int importantValue3 = importantValue2 * 7;

        return importantValue3 - 2 * importantValue1;
    }
}

接下来我就可以任意对compute()函数进行拆分了，完整代码如下

public class Account {

    private int gamma(int inputVal, int quantity, int yearToDate) {
        return new Gamma(this, inputVal, quantity, yearToDate).compute();
    }

    public int dalta() {
        return 1;
    }
}

class Gamma {
    private final Account account;
    private int inputVal;
    private int quantity;
    private int yearToDate;

    public Gamma(Account source, int inputValArg, int quantityArg,
            int yearToDateArg) {
        this.account = source;
        this.inputVal = inputValArg;
        this.quantity = quantityArg;
        this.yearToDate = yearToDateArg;
    }

    public int compute() {
        return importantValue3() - 2 * importantValue1();
    }

    private int importantValue3() {
        return importantThing(importantValue2()) * 7;
    }

    private int importantThing(int importantValue2) {
        if ((yearToDate - importantValue1()) > 100) {
            importantValue2 -= 20;
        }
        return importantValue2;
    }

    private int importantValue2() {
        return (inputVal * yearToDate) + 100;
    }

    private int importantValue1() {
        return (inputVal * quantity) + this.account.dalta();
    }
}