【重构】Android Studio在代码重构中的妙用
- 2019 年 11 月 7 日
- 筆記
代码重构几乎是每个程序员在软件开发中必须要不断去做的事情，以此来不断提高代码的质量。Android Stido（以下简称AS）以其强大的功能，成为当下Android开发工程师最受欢迎的开发工具，也是Android官方推荐使用的工具。如此优秀的工具，自然少不了要在代码重构这件事情上好好表现一把了。本文将通过代码演示，功能截图来详细介绍AS为代码重构提供的各项功能。
在AS的主菜单栏中有一项“Refactor”下拉菜单，点击该下拉菜单，会看到如下的界面，菜单中的每一项，都是为代码重构提供的一项自动实现功能。这么多的功能项，可见AS在代码重构功能上的强大，下面我们对这些功能项一一进行介绍。另外，还可以在编辑界面中点击右键，在弹出的菜单中也可以找到“Refactor”。
1、Refactor This
作用：重构当前。操作此项，会显示对当前光标选中处可行的重构方法。
示例：选择了类名“RefactorTest”，操作“Refactor This”后，显示了可执行的重构方法列表，可以通过选择数字来执行对应的方法。
2、Rename
作用：对光标选中项进行重命名。不仅可以对类中的成员变量进行重命名，还能对文件名，包名等进行重命名，Module中与之相关联的所有地方都会一起修改，而不用一一手动修改。
快捷键：Shift + F6
示例：在红框中输入修改后的名称，并按Enter键即可。
3、Rename File
作用：修改当前编辑界面显示的文件的文件名。就相当于鼠标选中该文件，并执行“Rename”方法。
示例：在显示的对话框中输入新文件名。可以在下方的选项框中选择修改范围，引用该文件的地方，注释，字符串中都可以选择一起修改。
4、Change Signature
作用：修改方法、类、构造函数的签名，其实就是修改所选项的一些属性。
快捷键：Ctr l+ F6
示例：如下展示了一个方法重构前，重构过程，以及重构后的情形（以修改一个方法签名为例）。
重构前：
1 private void testChangeSignature(int first, int second) { 2 }
选中方法名后，执行该重构方法后，会弹出如下对话框，可以对该方法各种属性进行修改，添加/删除参数，调整参数顺序，新增/删除异常等。
重构后：
1 public void testChangeSignature(int second, int first, String third) throws NullPointerException { 2 }
5、Type Migration
作用：类型迁移，即对变量数据类型，或者方法的返回类型进行修改。前面介绍了对文件名，包名，变量名等进行修改，这里对类型进行修改。
快捷键：Ctrl + Shift + F6
重构前：
1 private int age = 10; 2 public RefactorTest(int age) { 3 this.age = age; 4 }
选中要修改的类型，执行该重构方法，会弹出对话框，根据需要编辑类型，选中作用范围即可。指定范围内，与该变量相关联处都会被修改。
重构后（由于从int修改到String，所以还需要手动修改变量值）：
1 private String age = "10"; 2 public RefactorTest(String age) { 3 this.age = age; 4 }
6、Make Static
作用：给内部类或者方法添加static关键字。示例比较简单，就不做演示了。
7、Convert To Instance Method
作用： 转换为实例方法，即将静态方法去掉static关键字。
8、Move
功能：移动文件到指定路径
快捷键：F6
9、Copy
作用：在指定包中拷贝一份当前文件
快捷键：F5
10、Safe Detele
作用：安全删除，可用于对方法/字段等进行快速删除，会删除掉与之相关联的引用。
快捷键：Alt + Delete
11、Extract
（1）Variable
作用：提取变量。这一点在碰到比较长的表达式时经常用到，将看起来很长很复杂的表达式提取出来作为一个变量表示。
快捷键：Ctrl + Alt + V
重构前：我们常会看到这样的代码
1 public void testExtractVariable() { 2 Log.i("demo", "age=" + getAaaaaaaaaaaaaaaaaaaaaaaaaaaAge() + ";name=" + getNnnnnnnnnnnnnnnnnnnnnnname()); 3 } 4 private int getAaaaaaaaaaaaaaaaaaaaaaaaaaaAge() { 5 return age; 6 } 7 private String getNnnnnnnnnnnnnnnnnnnnnnname() { 8 return name; 9 }
第二行的要打印的信息表达式太长了，希望单独提取出来用一个变量表示。本示例中鼠标停留在第2行“getAaaaaaaaaaaaaaaaaaaaaaaaaaaAge”处，执行该重构方法，会弹出如下红框部分对话框，显示的是选中表达式相关的可提取部分，根据需要选择要提取的部分即可。
重构后：
1 public void testExtractVariable() { 2 String msg = "age=" + getAaaaaaaaaaaaaaaaaaaaaaaaaaaAge() + ";name=" + getNnnnnnnnnnnnnnnnnnnnnnname(); 3 Log.i("demo", msg); 4 } 5 private int getAaaaaaaaaaaaaaaaaaaaaaaaaaaAge() { 6 return age; 7 } 8 private String getNnnnnnnnnnnnnnnnnnnnnnname() { 9 return name; 10 }
（2）Constant
作用：提取常量，将表达式中的值提取为常量。
快捷键：Ctrl + Alt +C
重构前：
1 public void testExtractConstant() { 2 String filename = "sdcard"; 3 }
重构后：
1 public static final String SDCARD = "sdcard"; 2 public void testExtractConstant() { 3 String filename = SDCARD; 4 }
（3）Filed
作用：提取字段，将局部变量提取为全局变量。
快捷键：Ctrl + Alt +F
重构前：
1 public void testExtractField() { 2 String name ="zhangsan"; 3 }
重构后：
1 private final String string = "zhangsan"; 2 public void testExtractField() { 3 }
（4）Parameter
作用：将局部变量提取为方法的参数。
快捷键：Ctrl + Alt +P
重构前：
1 public void testExtractParameter() { 2 printName(); 3 } 4 private void printName(){ 5 String name = "zhangsan"; 6 Log.i("demo","My name is:"+name); 7 }
重构后：
1 public void testExtractParameter() { 2 printName("zhangsan"); 3 } 4 private void printName(String name){ 5 Log.i("demo","My name is:"+ name); 6 }
（5）Functional Parameter （ 函数式参数 ） Ctrl + Alt + Shift + P
（6）Parameter Object
作用：将参数提取为一个对象。该功能主要是针对参数比较多的时候，将这些参数提取出来作为一个Bean实例传入。
重构前：
1 private void testExtractParamObject() { 2 String info = getInfo("zhangshan", 20, 180f); 3 } 4 private String getInfo(String name, int age, float height) { 5 return "name=" + name + ";age=" + age + ";height=" + height; 6 }
重构后：
1 private void testExtractParamObject() { 2 String info = getInfo(new Person("zhangshan", 20, 180f)); 3 } 4 private String getInfo(Person person) { 5 return "name=" + person.getName() + ";age=" + person.getAge() + ";height=" + person.getHeight(); 6 } 7 private static class Person { 8 private final String name; 9 private final int age; 10 private final float height; 11 private Person(String name, int age, float height) { 12 this.name = name; 13 this.age = age; 14 this.height = height; 15 } 16 public String getName() { 17 return name; 18 } 19 public int getAge() { 20 return age; 21 } 22 public float getHeight() { 23 return height; 24 } 25 }
（7）Mehtod
作用：提取为方法
快捷键：Ctrl + Alt +M
重构前：
1 public void testExtractMethod() { 2 List<String> nameList = new ArrayList<>(); 3 nameList.add("zhangshan"); 4 nameList.add("lisi"); 5 nameList.add("wangwu"); 6 int size = nameList.size(); 7 }
鼠标光标选中第2~5行后执行该重构方法
重构后：
1 public void testExtractMethod() { 2 List<String> nameList = getNameList(); 3 int size = nameList.size(); 4 } 5 @NonNull 6 private List<String> getNameList() { 7 List<String> nameList = new ArrayList<>(); 8 nameList.add("zhangshan"); 9 nameList.add("lisi"); 10 nameList.add("wangwu"); 11 return nameList; 12 }
（8）Type Parameter
（9）Method Object
作用：将该选中的内容提取为一个方法，并提取到一个独立的类中。和“Method”很类似，不同的是提取的方法最后放在哪里。
重构前：
1 public void testExtractMethod() { 2 List<String> nameList = new ArrayList<>(); 3 nameList.add("zhangshan"); 4 nameList.add("lisi"); 5 nameList.add("wangwu"); 6 int size = nameList.size(); 7 }
重构后：
1 public void testExtractMethod() { 2 List<String> nameList = Utils.invoke(); 3 int size = nameList.size(); 4 } 5 private static class Utils { 6 private static List<String> invoke() { 7 List<String> nameList = new ArrayList<>(); 8 nameList.add("zhangshan"); 9 nameList.add("lisi"); 10 nameList.add("wangwu"); 11 return nameList; 12 } 13 }
（10）Delegate
作用：提取为一个代理类。
重构前：
1 public class RefactorTest{ 2 3 public void testExtractInterface() { 4 System.out.print("testExtractInterface"); 5 } 6 }
重构后：
1 public class RefactorTestDelegate { 2 public RefactorTestDelegate() { 3 } 4 5 public void testExtractInterface() { 6 System.out.print("testExtractInterface"); 7 } 8 } 9 10 public class RefactorTest{ 11 12 private final RefactorTestDelegate refactorTestDelegate = new RefactorTestDelegate(); 13 14 public void testExtractInterface() { 15 refactorTestDelegate.testExtractInterface(); 16 } 17 }
（11）Interrface
作用：提取为接口。
重构前：
1 public class RefactorTest { 2 3 public void testExtractInterface() { 4 System.out.print("testExtractInterface"); 5 } 6 }
public修饰的方法才可以被提取到接口中。
重构后：
1 interface IRefactorTest { 2 void testExtractInterface(); 3 } 4 5 public class RefactorTest implements IRefactorTest { 6 7 @Override 8 public void testExtractInterface() { 9 System.out.print("testExtractInterface"); 10 } 11 }
（12）Superclass
作用：将指定内容提取到父类中。
重构前：
1 private void testExtractSupperclass() { 2 testSuper(); 3 } 4 5 public void testSuper() { 6 System.out.print("testSuper"); 7 }
重构后：
1 //=======RefactorTest extends RefactorTestBase======= 2 private void testExtractSupperclass() { 3 testSuper(); 4 } 5 6 class RefactorTestBase { 7 public void testSuper() { 8 System.out.print("testSuper"); 9 } 10 }
12、Inline
作用：转换为内联、方法链形式的调用。
快捷键：Ctrl + Alt +N
重构前：
1 private void testInline() { 2 int a = 100; 3 int b = 200; 4 System.out.print(add(a, b)); 5 } 6 private int add(int a, int b) { 7 System.out.print("a=" + a + ";b=" + b); 8 return a*2 + b*3; 9 }
重构后：
1 private void testInline() { 2 int a = 100; 3 int b = 200; 4 System.out.print("a=" + a + ";b=" + b); 5 System.out.print(a * 2 + b * 3); 6 }
原先需要调用一个方法，重构后直接把该方法中的代码给复制过来了。因为上面选中的是内联所有的，并且删除该方法，所以add方法也就被删除了。
13、Find and Replace Code Duplicates
14、Invert Boolean
作用：转换Boolean值，将当前false/true的值进行转化为相反的值。
重构前：
1 private boolean isEmpty(String str) { 2 if (str != null && str.length() == 0) { 3 return false; 4 } 5 return true; 6 }
重构后：
1 private boolean isNotEmpty(String str) { 2 if (str != null && str.length() == 0) { 3 return true; 4 } 5 return false; 6 }
15、Pull Members Up
作用：将子类的成员上移到父类中。
重构前：
1 public class RefactorBase { 2 3 } 4 5 public class RafactorSub extends RefactorBase { 6 int age = 10; 7 8 public void printSub() { 9 System.out.print(age); 10 } 11 }
重构后：
1 public class RefactorBase { 2 int age = 10; 3 public void printSub() { 4 System.out.print(age); 5 } 6 } 7 8 public class RafactorSub extends RefactorBase { 9 10 }
16、Push Members Down
作用：将父类中的成员下移到子类中，正好是“Pull Members Up”的反向操作。
重构前：
1 public class RefactorBase { 2 int age = 10; 3 public void printSub() { 4 System.out.print(age); 5 } 6 } 7 8 public class RafactorSub extends RefactorBase { 9 10 }
重构后：
1 public class RefactorBase { 2 3 } 4 public class RafactorSub extends RefactorBase { 5 int age = 10; 6 public void printSub() { 7 System.out.print(age); 8 } 9 }
17、Use Interface Where Possible
18、Replace Inheritance with Delegation
作用：使用代理替代继承。在java中，提倡使用组合，而不是继承。
重构前：
1 public abstract class AbsClass { 2 public abstract void print(); 3 } 4 5 public class ClassWrapper extends AbsClass { 6 @Override 7 public void print() { 8 System.out.print("print"); 9 } 10 } 11 12 private void testReplaceInheritanceWithDelegation() { 13 new ClassWrapper().print(); 14 }
重构后：
1 public abstract class AbsClass { 2 public abstract void print(); 3 } 4 5 public class ClassWrapper { 6 private final ClassImpl absClass = new ClassImpl(); 7 8 public void print() { 9 absClass.print(); 10 } 11 12 private class ClassImpl extends AbsClass { 13 @Override 14 public void print() { 15 System.out.print("print"); 16 } 17 } 18 } 19 20 public class RefactorTest { 21 private void testReplaceInheritanceWithDelegation() { 22 new ClassWrapper().print(); 23 } 24 }
这一部分有点像Android中Context，ContextWrapper，ContextImpl类之间的关系。
19、Remove Middleman
作用：移除中间人，其实就是移除中间过程。
重构前：
1 public class RefactorTest { 2 3 private void testRemoveMiddleMan() { 4 BookManager bookManager = new BookManager(); 5 bookManager.addBook("java"); 6 } 7 8 public static class BookManager { 9 private List<String> mBookList = new ArrayList<>(); 10 11 private void addBook(String bookName) { 12 mBookList.add(bookName); 13 } 14 } 15 }
重构后：
1 public class RefactorTest { 2 3 private void testRemoveMiddleMan() { 4 BookManager bookManager = new BookManager(); 5 bookManager.getmBookList().add("java"); 6 } 7 8 public static class BookManager { 9 private List<String> mBookList = new ArrayList<>(); 10 11 public List<String> getmBookList() { 12 return mBookList; 13 } 14 } 15 }
对比重构前和重构后会发现，添加book这个动作，从由BookManager的addBook方法来执行，变成了直接有mBookList来执行了。这个addBook就是这个MiddleMan，显得多余，可以优化掉。实际上优化后就变成一个inline方式了，可以对比前面讲到的“Inline”。
20、Wrap Method Return Value
作用：封装返回值
1 public class RefactorTest { 2 3 private void testWrapReturnValue() { 4 String name = getName(); 5 } 6 7 private String getName() { 8 return "zhangsan"; 9 } 10 }
重构后：
1 public class RefactorTest { 2 3 private void testWrapReturnValue() { 4 String name = getName().getValue(); 5 } 6 7 private Person getName() { 8 return new Person("zhangsan"); 9 } 10 11 public class Person { 12 private final String value; 13 14 public Person(String value) { 15 this.value = value; 16 } 17 18 public String getValue() { 19 return value; 20 } 21 } 22 }
21、Convert Anonymous to Inner
作用：将匿名内部类转为内部类。
重构前：
1 private void testConvertAnonymousToInner(){ 2 view.setOnClickListener(new View.OnClickListener() { 3 @Override 4 public void onClick(View v) { 5 } 6 }); 7 }
重构后：
1 public class RefactorTest{ 2 3 View view; 4 private void testConvertAnonymousToInner(){ 5 view.setOnClickListener(new MyOnClickListener()); 6 } 7 8 private static class MyOnClickListener implements View.OnClickListener { 9 @Override 10 public void onClick(View v) { 11 12 } 13 } 14 }
22、Encapsulate Fields
作用：封装字段，用于生成Getter/Setter
重构前：
1 public String name = "zhangsan"; 2 private void testEncapsulateFields() { 3 System.out.println(name); 4 }
通过该对话框，可以选择要封装的字段，设置修饰符等。默认选择时，name字段的修饰符从public变成了private，这也就避免了外部类通过实例直接访问它。
重构后：
1 private String name = "zhangsan"; 2 private void testEncapsulateFields() { 3 System.out.println(getName()); 4 } 5 public String getName() { 6 return name; 7 } 8 public void setName(String name) { 9 this.name = name; 10 }
23、Replace Temp With Query
24、Replace Constructor with Factory Method
作用：将构造方法替换为工厂方法
重构前：
1 public class MyClass { 2 3 private String title; 4 private String message; 5 private String sure; 6 private String cancel; 7 8 public MyClass(String title, String message, String sure, String cancel) { 9 this.title = title; 10 this.message = message; 11 this.sure = sure; 12 this.cancel = cancel; 13 } 14 } 15 16 public class RefactorTest { 17 private void testReplaceConstructorWithFactory(Context context) { 18 MyClass myClass = new MyClass("title", "message", "sure", "cancle"); 19 } 20 }
重构后：
1 public class MyClass { 2 3 private String title; 4 private String message; 5 private String sure; 6 private String cancel; 7 8 private MyClass(String title, String message, String sure, String cancel) { 9 this.title = title; 10 this.message = message; 11 this.sure = sure; 12 this.cancel = cancel; 13 } 14 15 public static MyClass createMyClass(String title, String message, String sure, String cancel) { 16 return new MyClass(title, message, sure, cancel); 17 } 18 } 19 20 public class RefactorTest { 21 private void testReplaceConstructorWithFactory(Context context) { 22 MyClass myClass = MyClass.createMyClass("title", "message", "sure", "cancle"); 23 } 24 }
原先public修饰的构造函数，已经变成private了，MyClass类只能通过工厂方法来获取实例，而无法再直接new了。
25、Replace Constructor with Builder
作用：将构造方法替换为Builder方式
重构前：
1 public class RefactorTest{ 2 private void testReplaceConstructorWithBuilder(Context context){ 3 MyDialog dialog = new MyDialog(context,"title","message","sure","cancle"); 4 } 5 } 6 7 public class MyDialog extends Dialog { 8 private String title; 9 private String message; 10 private String sure; 11 private String cancel; 12 public MyDialog(@NonNull Context context) { 13 super(context); 14 } 15 public MyDialog(Context context, String title, String message, String sure, String cancel) { 16 super(context); 17 this.title = title; 18 this.message = message; 19 this.sure = sure; 20 this.cancel = cancel; 21 } 22 }
重构后：
1 public class RefactorTest { 2 private void testReplaceConstructorWithBuilder(Context context) { 3 MyDialog dialog = new MyDialogBuilder() 4 .setContext(context) 5 .setTitle("title") 6 .setMessage("message") 7 .setSure("sure") 8 .setCancel("cancle") 9 .createMyDialog(); 10 } 11 } 12 13 public class MyDialogBuilder { 14 private Context context; 15 private String title; 16 private String message; 17 private String sure; 18 private String cancel; 19 20 public MyDialogBuilder setContext(Context context) { 21 this.context = context; 22 return this; 23 } 24 25 public MyDialogBuilder setTitle(String title) { 26 this.title = title; 27 return this; 28 } 29 30 public MyDialogBuilder setMessage(String message) { 31 this.message = message; 32 return this; 33 } 34 35 public MyDialogBuilder setSure(String sure) { 36 this.sure = sure; 37 return this; 38 } 39 40 public MyDialogBuilder setCancel(String cancel) { 41 this.cancel = cancel; 42 return this; 43 } 44 45 public MyDialog createMyDialog() { 46 return new MyDialog(context); 47 } 48 }
看到这里，我们应该能够联想到AlertDialog类中的Builder了。将构造函数的形式，转变为了建造者模式的形式，这样不会拘泥于构造函数的参数个数，参数类型的限制，从而灵活设置属性。
26、Generify
作用：泛型重构，自动添加泛型的参数。
重构前：
1 private void testGenerify() { 2 List list = new ArrayList(); 3 list.add("one"); 4 list.add("two"); 5 list.add("three"); 6 }
重构后：
1 private void testGenerify() { 2 List<String> list = new ArrayList<String>(); 3 list.add("one"); 4 list.add("two"); 5 list.add("three"); 6 }
27、Migrate
28、Internationalize（国际化）
29、Remove Unused Resources
作用：一直不用的资源
示例：下图中1.jpg是一个没有被应用的文件。
在执行该重构方法后，1.jpg就被删除了。
参考：https://www.jianshu.com/p/f8cb51bc8e19
