重构手法--对象内

重构手法–对象内

Extract Method(提炼函数)

将一段需要加注释的函数放进一个独立函数中，并让函数名称解释该函数的用途，因为函数约简短被复用的机会就越大。
重构前的代码：

void printOwing(){
	Enumeration e = _order.elements();
	double outstanding = 0.0;
	
	//print banner
	System.out.println("*************************");
	System.out.println("***** Customer Owes *****");
	System.out.println("*************************");

	//calculate outstanding
	while(e.hasMoreElements()){
		Order each = (Order)e.nextElement();
		outstanding += each.getAmount();
	}

	//print details
	System.out.println("name:"+_name);
	System.out.println("amount"+outstanding);
}

重构后的代码：

void printOwing(){
	printBanner();
	printDetails(getOutstanding())
}

void printBanner(){
	System.out.println("*************************");
	System.out.println("***** Customer Owes *****");
	System.out.println("*************************");
}	

double getOutstanding(){
	Enumeration e = _order.elements();
	double result = 0.0;
	while(e.hasMoreElements()){
		Order each = (Order)e.nextElement();
		result += each.getAmount();
	}
	return result;
}

void printDetails(double outstanding){
	System.out.println("name:"+_name);
	System.out.println("amount"+outstanding);
}

Inline Method(内联函数)

过分提炼的函数，用函数体代替该函数更能让代码清晰
重构前的代码：

int getRating(){
	return (moreThanFiveLateDeliveries()) ? 2 : 1;
}

boolean moreThanFiveLateDeliveries(){
	return _numberOfLateDeliveries > 5;
}

重构后的代码：

int getRating(){
	return (_numberOfLateDeliveries > 5) ? 2 : 1;
}

Inline Temp(内联临时变量)

只被一个简单表达式赋值一次的临时变量，不如把它替换为赋值的那个表达式本身
重构前的代码：

double basePrice = anOrder.basePrice();
return (basePrice > 1000)

重构后的代码：

return (anOrder.basePrice() > 1000);

Replace Temp with Query(以查询取代临时变量)

将表达式提炼到一个独立函数中，去掉保存该表达式结果的临时变量，为了该表达式可以被复用。
重构前的代码：

double basePrice = _quantity * _itemPrice;
if(basePrice > 1000)
	return basePrice * 0.95;
else
	return basePrice * 0.98;

重构后的代码：

if(basePrice() > 1000)
	return basePrice() * 0.95;
else
	return basePrice() * 0.98;

...
double basePrice(){
	return _quantity * _itemPrice;;
}

Introduce Explaining Variable(引入解释性变量)

当表达式比较复杂时，把表达式的结果放进临时变量里，个人理解这个重构手法没啥用
重构前的代码：

if((platform.toUpperCase().indexOf("MAC") > -1) && 
	(browser.toUpperCase().indexOf("IE") > -1) &&
	wasInitialized() && resize > 0){
	
	//do something
}

利用该重构手法重构后的代码：

final boolean isMacOs = platform.toUpperCase().indexOf("MAC") > -1;
final boolean isIEBrowser = browser.toUpperCase().indexOf("IE") > -1;
final boolean wasResized = resize > 0;

if(isMacOs && isIEBrowser && wasInitialized() && wasResized){
	//do something
}

个人感觉使用Extract Method(提炼函数)方法会更好：

if(isMacOs() && isIEBrowser() && wasInitialized() && wasResized()){
	//do something
}

boolean isMacOs(){
	return platform.toUpperCase().indexOf("MAC") > -1;
}
boolean isIEBrowser(){
	return browser.toUpperCase().indexOf("IE") > -1;
}
boolean wasResized(){
	return resize > 0;
}

Split Temporary Variable(分解临时变量)

一个临时变量只承担一种意义的变量赋值，如果被多种含义的变量赋值多次就会影响代码阅读
重构前的代码：

double temp = 2 * (_height + _width);
System.out.println(temp);
temp = _height * _width;
System.out.println(temp);

重构后的代码：

final double temp = 2 * (_height + _width);
System.out.println(temp);
final double area = _height * _width;
System.out.println(temp);

Remove Assignments to Parameters(移除对参数的赋值)

用临时变量取代直接对参数进行赋值的操作，为了代码便于阅读
重构前的代码：

int discount(int inputVal, int quantity, int yearToDate){
	if(inputVal > 50)
		inputVal -= 2;

	return inputVal;
}

重构后的代码：

int discount(int inputVal, int quantity, int yearToDate){
	int result = inputVal;
	if(inputVal > 50)
		result -= 2;

	return result;
}

Replace Method with Method Object(以函数对象取代函数)

如果一个比较大的函数里局部变量很多，导致无法直接对该函数进行Extract Method(提炼)，这时候就可以把该函数放进一个单独对象里再提炼
重构前的代码：

class Account{
	int gamma(int inputVal, int quantity, int yearToDate){
		int importantValue1 = (inputVal * quantity) + delta();
		int importantValue2 = (inputVal * yearToDate) + 100;
		if((yearToDate - importantValue) > 100){
			importantValue2 -= 20;
		}
		int importantValue3 = importantValue2 * 7;
		return importantValue3 - 2 * importantValue1;
	}
}

重构后的代码：

class Gamma{
	private final Account _account;
	private int inputVal;
	private int quantity;
	private int yearToDate;
	private int importantValue1;
	private int importantValue2;
	private int importantValue3;

	Gamma(Account source,int inputValArg, int quantityArg,int yearToDateArg){
		_account = source;
		inputVal = inputValArg;
		quantity = quantityArg;
		yearToDate = yearToDateArg;
	}

	int compute(){
		importantValue1 = (inputVal * quantity) + _account.delta();
	 	importantValue2 = (inputVal * yearToDate) + 100;
		importantThing();
		importantValue3 = importantValue2 * 7;
		return importantValue3 - 2 * importantValue1;
	}

	void importantThing(){
		if((yearToDate - importantValue) > 100){
			importantValue2 -= 20;
		}
	}
}

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

Substitute Algorithm(替换算法)

将某个算法替换为另一个更清晰的算法
重构前的代码：

String foundPerson(String[] people){
	for(int i = 0;i < people.lenght; i++){
		if(people[i].equals("Don")){
			return "Don";
		}
		if(people[i].equals("John")){
			return "John";
		}
		if(people[i].equals("Kent")){
			return "Kent";
		}
	}
	return "";
}

重构后的代码：

String foundPerson(String[] people){
	List candidates = Arrays.asList(new String[] {"Don","John","Kent"});
	for(int i = 0;i < people.lenght; i++){
		if(candidates.contains(people[i])){
			return people[i];
		}
	}
	return "";
}