重构《Split Loop（分解循环）》
WHAT
在循环中，一次循环做了两件事情，将循环分解，重复这个循环，每次只做一件事情
潜在问题：性能问题，如果遇到性能问题，先让代码清晰可读，让你更快找到性能优化点，再做优化
本次重构涉及的基本重构较多，主要有：
- Split Loop（分解循环）
- Extract Method（提炼方法）
- Inline Temp（内联临时变量）
- Replace Temp With Query（用查询函数代替临时变量）
- Rename Temp（重命名临时变量）
- Split Temporary Variable（分解临时变量）
HOW
重构前的代码清单
Student类是一个哑对象，表示一个学生，有年龄（age）和成绩（grade）两个属性
package split.loop;
public class Student {
/**
* 年龄
*/
private int age;
/**
* 成绩
*/
private int grade;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public int getGrade() {
return grade;
}
public void setGrade(int grade) {
this.grade = grade;
}
}
下面方法
printValues()，用于计算学生们的平均年龄和总成绩
package split.loop;
public class SomeClass {
private Student[] students;
void printValues() {
double averageAge = 0; // 平均年龄
int totalGrade = 0; // 总成绩
for (int i = 0; i < students.length; i++) {
averageAge += students[i].getAge();
totalGrade += students[i].getGrade();
}
averageAge = averageAge / students.length;
System.out.println(averageAge);
System.out.println(totalGrade);
}
}
重构步骤
- （手动）拷贝for循环语句，并除掉各自不相干部分代码，重构后的代码清单
package split.loop;
public class SomeClass {
private Student[] students;
void printValues() {
double averageAge = 0; // 平均年龄
int totalGrade = 0; // 总成绩
for (int i = 0; i < students.length; i++) {
averageAge += students[i].getAge();
}
for (int i = 0; i < students.length; i++) {
totalGrade += students[i].getGrade();
}
averageAge = averageAge / students.length;
System.out.println(averageAge);
System.out.println(totalGrade);
}
}
- （手动）重新组织语句，让语义相近（for循环中使用到的局部变量）的语句放在一组，为其他重构做好准备，重构后的代码清单
package split.loop;
public class SomeClass {
private Student[] students;
void printValues() {
double averageAge = 0; // 平均年龄
for (int i = 0; i < students.length; i++) {
averageAge += students[i].getAge();
}
averageAge = averageAge / students.length;
int totalGrade = 0; // 总成绩
for (int i = 0; i < students.length; i++) {
totalGrade += students[i].getGrade();
}
System.out.println(averageAge);
System.out.println(totalGrade);
}
}
延伸重构
- 本次重构，到此本应该结束，但是，我们还可以继续重构，让代码更优雅。我们观察到，上述代码清单中，printValues方法仍旧很长，到处充满了局部解释性变量（令人疑惑的东西），可以使用Replace Temp with Query（用查询函数代替临时变量，其实这个重构手法应用了两个基本的重构手法：Extract Method（提炼方法）和Inline Temp（内联临时变量）），我们可以一步步来操作
- 首先处理临时变量：averageAge，对上一组方法 Extract Method（提炼方法），使用快捷键（Alt + Shift +M）或者上下文菜单（Refactor -> Extract Method...）,这里 averageAge ，在for循环前初始化，并在for循环中赋值，最后在for循环结束后，再次赋值。因此我们选中for循环以及前后语句，一起提炼，并给方法取个好名字（ averageAge ，这个方法是干什么的），提炼后的代码清单
package split.loop;
public class SomeClass {
private Student[] students;
void printValues() {
double averageAge = averageAge();
int totalGrade = 0; // 总成绩
for (int i = 0; i < students.length; i++) {
totalGrade += students[i].getGrade();
}
System.out.println(averageAge);
System.out.println(totalGrade);
}
private double averageAge() {
double averageAge = 0; // 平均年龄
for (int i = 0; i < students.length; i++) {
averageAge += students[i].getAge();
}
averageAge = averageAge / students.length;
return averageAge;
}
}
-
- 接下来，处理新提炼出来的方法averageAge，按照惯例，我们把方法的返回值命名为result，使用快捷键（Alt + Shit + R）或者上下文菜单（Refactor > Rename ...），改名之后，直接回车即可，代码清单
package split.loop;
public class SomeClass {
private Student[] students;
void printValues() {
double averageAge = averageAge();
int totalGrade = 0; // 总成绩
for (int i = 0; i < students.length; i++) {
totalGrade += students[i].getGrade();
}
System.out.println(averageAge);
System.out.println(totalGrade);
}
private double averageAge() {
double result = 0; // 平均年龄
for (int i = 0; i < students.length; i++) {
result += students[i].getAge();
}
result = result / students.length;
return result;
}
}
-
- 在往下，这里又涉及到一个问题，就是对局部变量赋值了多次，这时，需要应用Split Temporary Variable（手动操作，在第二次赋值的地方，重新声明变量，并更新接下来的引用），重构后的代码清单
package split.loop;
public class SomeClass {
private Student[] students;
void printValues() {
double averageAge = averageAge();
int totalGrade = 0; // 总成绩
for (int i = 0; i < students.length; i++) {
totalGrade += students[i].getGrade();
}
System.out.println(averageAge);
System.out.println(totalGrade);
}
private double averageAge() {
double result = 0; // 平均年龄
for (int i = 0; i < students.length; i++) {
result += students[i].getAge();
}
double result1 = result / students.length;
return result1;
}
}
-
- 这时，我们注意到，result1变量只被赋值一次，我们将它内联，应用Inline temp （内联临时变量 ），选中变量，使用快捷键（Alt +Shift + I）或者上下文菜单（Refactor > Inline ...） ，重构后的代码清单
package split.loop;
public class SomeClass {
private Student[] students;
void printValues() {
double averageAge = averageAge();
int totalGrade = 0; // 总成绩
for (int i = 0; i < students.length; i++) {
totalGrade += students[i].getGrade();
}
System.out.println(averageAge);
System.out.println(totalGrade);
}
private double averageAge() {
double result = 0; // 平均年龄
for (int i = 0; i < students.length; i++) {
result += students[i].getAge();
}
return result / students.length;
}
}
-
- 这时，我们回到调用处，发现printValues方法中，averageAge 变量只被赋值一次，我们也把它Inline掉，重构后的代码清单
package split.loop;
public class SomeClass {
private Student[] students;
void printValues() {
int totalGrade = 0; // 总成绩
for (int i = 0; i < students.length; i++) {
totalGrade += students[i].getGrade();
}
System.out.println(averageAge());
System.out.println(totalGrade);
}
private double averageAge() {
double result = 0; // 平均年龄
for (int i = 0; i < students.length; i++) {
result += students[i].getAge();
}
return result / students.length;
}
}
- 接下来，同样方法处理这个变量：totalGrade
- 首先，提炼方法，并重名返回结果变量名
package split.loop;
public class SomeClass {
private Student[] students;
void printValues() {
int totalGrade = totalGrade();
System.out.println(averageAge());
System.out.println(totalGrade);
}
private double averageAge() {
double result = 0; // 平均年龄
for (int i = 0; i < students.length; i++) {
result += students[i].getAge();
}
return result / students.length;
}
private int totalGrade() {
int result = 0; // 总成绩
for (int i = 0; i < students.length; i++) {
result += students[i].getGrade();
}
return result;
}
}
-
- 在调用处，inline临时变量totalGrade，重构后的的代码清单
package split.loop;
public class SomeClass {
private Student[] students;
void printValues() {
System.out.println(averageAge());
System.out.println(totalGrade());
}
private double averageAge() {
double result = 0; // 平均年龄
for (int i = 0; i < students.length; i++) {
result += students[i].getAge();
}
return result / students.length;
}
private int totalGrade() {
int result = 0; // 总成绩
for (int i = 0; i < students.length; i++) {
result += students[i].getGrade();
}
return result;
}
}
- 这时，代码已经相当清晰了，我们不需要看方法注释，以及方法内部实现，就可以知道printValues这个方法做了哪些事情，这就是重构的魅力，小步慢跑，一步一前进，但是，最最重要的前提是：我们在重构之前，必须有一个运行良好且速度较快的单元测试，让我们在测试、编码、重构不断地切换角色，更换帽子
总结
本重构虽然很简单，一些很小的改动，能够使代码可读性更强，更易维护，希望本实践对你有益，希望大家和我一起动手做重构，也希望你提出宝贵意见或反馈