这篇文章主要介绍AndroidStudio中代码重构菜单Refactor功能有哪些，文中介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们一定要看完！

创新互联公司专注为客户提供全方位的互联网综合服务，包含不限于成都网站建设、网站设计、曲麻莱网络推广、小程序定制开发、曲麻莱网络营销、曲麻莱企业策划、曲麻莱品牌公关、搜索引擎seo、人物专访、企业宣传片、企业代运营等，从售前售中售后，我们都将竭诚为您服务，您的肯定，是我们大的嘉奖；创新互联公司为所有大学生创业者提供曲麻莱建站搭建服务，24小时服务热线：028-86922220，官方网址：www.cdcxhl.com

在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

示例：如下展示了一个方法重构前，重构过程，以及重构后的情形（以修改一个方法签名为例）。

重构前：

private void testChangeSignature(int first, int second) { }

选中方法名后，执行该重构方法后，会弹出如下对话框，可以对该方法各种属性进行修改，添加/删除参数，调整参数顺序，新增/删除异常等。

重构后：

public void testChangeSignature(int second, int first, String third) throws NullPointerException {}

5、Type Migration

作用：类型迁移，即对变量数据类型，或者方法的返回类型进行修改。前面介绍了对文件名，包名，变量名等进行修改，这里对类型进行修改。

快捷键：Ctrl + Shift + F6

重构前：

private int age = 10; public RefactorTest(int age) { this.age = age; }

选中要修改的类型，执行该重构方法，会弹出对话框，根据需要编辑类型，选中作用范围即可。指定范围内，与该变量相关联处都会被修改。

重构后（由于从int修改到String，所以还需要手动修改变量值）：

private String age = "10"; public RefactorTest(String age) { this.age = age; }

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

重构前：我们常会看到这样的代码

public void testExtractVariable() { Log.i("demo", "age=" + getAaaaaaaaaaaaaaaaaaaaaaaaaaaAge() + ";name=" + getNnnnnnnnnnnnnnnnnnnnnnname()); } private int getAaaaaaaaaaaaaaaaaaaaaaaaaaaAge() { return age; } private String getNnnnnnnnnnnnnnnnnnnnnnname() { return name; }

第二行的要打印的信息表达式太长了，希望单独提取出来用一个变量表示。本示例中鼠标停留在第2行“getAaaaaaaaaaaaaaaaaaaaaaaaaaaAge”处，执行该重构方法，会弹出如下红框部分对话框，显示的是选中表达式相关的可提取部分，根据需要选择要提取的部分即可。

重构后：

public void testExtractVariable() { String msg = "age=" + getAaaaaaaaaaaaaaaaaaaaaaaaaaaAge() + ";name=" + getNnnnnnnnnnnnnnnnnnnnnnname(); Log.i("demo", msg);}private int getAaaaaaaaaaaaaaaaaaaaaaaaaaaAge() { return age;}private String getNnnnnnnnnnnnnnnnnnnnnnname() { return name;}

（2）Constant

作用：提取常量，将表达式中的值提取为常量。

快捷键：Ctrl + Alt +C

重构前：

public void testExtractConstant() { String filename = "sdcard"; }

重构后：

public static final String SDCARD = "sdcard"; public void testExtractConstant() { String filename = SDCARD; }

（3）Filed

作用：提取字段，将局部变量提取为全局变量。

快捷键：Ctrl + Alt +F

重构前：

public void testExtractField() { String name ="zhangsan";}

重构后：

private final String string = "zhangsan"; public void testExtractField() { }

（4）Parameter

作用：将局部变量提取为方法的参数。

快捷键：Ctrl + Alt +P

重构前：

public void testExtractParameter() { printName();}private void printName(){ String name = "zhangsan"; Log.i("demo","My name is:"+name);}

重构后：

public void testExtractParameter() { printName("zhangsan");}private void printName(String name){ Log.i("demo","My name is:"+ name); }

（5）Functional Parameter （ 函数式参数 ）Ctrl + Alt + Shift + P

（6）Parameter Object

作用：将参数提取为一个对象。该功能主要是针对参数比较多的时候，将这些参数提取出来作为一个Bean实例传入。

重构前：

private void testExtractParamObject() { String info = getInfo("zhangshan", 20, 180f);}private String getInfo(String name, int age, float height) { return "name=" + name + ";age=" + age + ";height=" + height;}

重构后：

private void testExtractParamObject() { String info = getInfo(new Person("zhangshan", 20, 180f));}private String getInfo(Person person) { return "name=" + person.getName() + ";age=" + person.getAge() + ";height=" + person.getHeight();}private static class Person { private final String name; private final int age; private final float height; private Person(String name, int age, float height) { this.name = name; this.age = age; this.height = height; } public String getName() { return name; } public int getAge() { return age; } public float getHeight() { return height; }}

（7）Mehtod

作用：提取为方法

快捷键：Ctrl + Alt +M

重构前：

public void testExtractMethod() { List nameList = new ArrayList<>(); nameList.add("zhangshan"); nameList.add("lisi"); nameList.add("wangwu"); int size = nameList.size();}

鼠标光标选中第2~5行后执行该重构方法

重构后：

public void testExtractMethod() { List nameList = getNameList(); int size = nameList.size();}@NonNullprivate List getNameList() { List nameList = new ArrayList<>(); nameList.add("zhangshan"); nameList.add("lisi"); nameList.add("wangwu"); return nameList;}

（8）Type Parameter

（9）Method Object

作用：将该选中的内容提取为一个方法，并提取到一个独立的类中。和“Method”很类似，不同的是提取的方法最后放在哪里。

重构前：

public void testExtractMethod() { List nameList = new ArrayList<>(); nameList.add("zhangshan"); nameList.add("lisi"); nameList.add("wangwu"); int size = nameList.size();}

重构后：

public void testExtractMethod() { List nameList = Utils.invoke(); int size = nameList.size();}private static class Utils { private static List invoke() { List nameList = new ArrayList<>(); nameList.add("zhangshan"); nameList.add("lisi"); nameList.add("wangwu"); return nameList; }}

（10）Delegate

作用：提取为一个代理类。

重构前：

public class RefactorTest{ public void testExtractInterface() { System.out.print("testExtractInterface"); }}

重构后：

public class RefactorTestDelegate { public RefactorTestDelegate() { } public void testExtractInterface() { System.out.print("testExtractInterface"); }}public class RefactorTest{ private final RefactorTestDelegate refactorTestDelegate = new RefactorTestDelegate(); public void testExtractInterface() { refactorTestDelegate.testExtractInterface(); }}

（11）Interrface

作用：提取为接口。

重构前：

public class RefactorTest { public void testExtractInterface() { System.out.print("testExtractInterface"); }}

public修饰的方法才可以被提取到接口中。

重构后：

interface IRefactorTest { void testExtractInterface();}public class RefactorTest implements IRefactorTest { @Override public void testExtractInterface() { System.out.print("testExtractInterface"); }}

（12）Superclass

作用：将指定内容提取到父类中。

重构前：

private void testExtractSupperclass() { testSuper();}public void testSuper() { System.out.print("testSuper");}

重构后：

//=======RefactorTest extends RefactorTestBase=======private void testExtractSupperclass() { testSuper();}class RefactorTestBase { public void testSuper() { System.out.print("testSuper"); }}

12、Inline

作用：转换为内联、方法链形式的调用。

快捷键：Ctrl + Alt +N

重构前：

private void testInline() { int a = 100; int b = 200; System.out.print(add(a, b));}private int add(int a, int b) { System.out.print("a=" + a + ";b=" + b); return a*2 + b*3;}

重构后：

private void testInline() { int a = 100; int b = 200; System.out.print("a=" + a + ";b=" + b); System.out.print(a * 2 + b * 3); }

原先需要调用一个方法，重构后直接把该方法中的代码给复制过来了。因为上面选中的是内联所有的，并且删除该方法，所以add方法也就被删除了。

13、Find and Replace Code Duplicates

14、Invert Boolean

作用：转换Boolean值，将当前false/true的值进行转化为相反的值。

重构前：

private boolean isEmpty(String str) { if (str != null && str.length() == 0) { return false; } return true; }

重构后：

private boolean isNotEmpty(String str) { if (str != null && str.length() == 0) { return true; } return false; }

15、Pull Members Up

作用：将子类的成员上移到父类中。

重构前：

public class RefactorBase {}public class RafactorSub extends RefactorBase { int age = 10; public void printSub() { System.out.print(age); }}

重构后：

public class RefactorBase { int age = 10; public void printSub() { System.out.print(age); }}public class RafactorSub extends RefactorBase {}

16、Push Members Down

作用：将父类中的成员下移到子类中，正好是“Pull Members Up”的反向操作。

重构前：

public class RefactorBase { int age = 10; public void printSub() { System.out.print(age); }} public class RafactorSub extends RefactorBase { }

重构后：

public class RefactorBase {}public class RafactorSub extends RefactorBase { int age = 10; public void printSub() { System.out.print(age); }}

17、Use Interface Where Possible

18、Replace Inheritance with Delegation

作用：使用代理替代继承。在java中，提倡使用组合，而不是继承。

重构前：

public abstract class AbsClass { public abstract void print();}public class ClassWrapper extends AbsClass { @Override public void print() { System.out.print("print"); }}private void testReplaceInheritanceWithDelegation() { new ClassWrapper().print();}

重构后：

public abstract class AbsClass { public abstract void print();}public class ClassWrapper { private final ClassImpl absClass = new ClassImpl(); public void print() { absClass.print(); } private class ClassImpl extends AbsClass { @Override public void print() { System.out.print("print"); } }}public class RefactorTest { private void testReplaceInheritanceWithDelegation() { new ClassWrapper().print(); }}

这一部分有点像Android中Context，ContextWrapper，ContextImpl类之间的关系。

19、Remove Middleman

作用：移除中间人，其实就是移除中间过程。

重构前：

public class RefactorTest { private void testRemoveMiddleMan() { BookManager bookManager = new BookManager(); bookManager.addBook("java"); } public static class BookManager { private List mBookList = new ArrayList<>(); private void addBook(String bookName) { mBookList.add(bookName); } }}

重构后：

public class RefactorTest { private void testRemoveMiddleMan() { BookManager bookManager = new BookManager(); bookManager.getmBookList().add("java"); } public static class BookManager { private List mBookList = new ArrayList<>(); public List getmBookList() { return mBookList; } }}

对比重构前和重构后会发现，添加book这个动作，从由BookManager的addBook方法来执行，变成了直接有mBookList来执行了。这个addBook就是这个MiddleMan，显得多余，可以优化掉。实际上优化后就变成一个inline方式了，可以对比前面讲到的“Inline”。

20、Wrap Method Return Value

作用：封装返回值

public class RefactorTest { private void testWrapReturnValue() { String name = getName(); } private String getName() { return "zhangsan"; }}

重构后：

public class RefactorTest { private void testWrapReturnValue() { String name = getName().getValue(); } private Person getName() { return new Person("zhangsan"); } public class Person { private final String value; public Person(String value) { this.value = value; } public String getValue() { return value; } }}

21、Convert Anonymous to Inner

作用：将匿名内部类转为内部类。

重构前：

private void testConvertAnonymousToInner(){ view.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { } });}

重构后：

public class RefactorTest{ View view; private void testConvertAnonymousToInner(){ view.setOnClickListener(new MyOnClickListener()); } private static class MyOnClickListener implements View.OnClickListener { @Override public void onClick(View v) { } }}

22、Encapsulate Fields

作用：封装字段，用于生成Getter/Setter

重构前：

public String name = "zhangsan"; private void testEncapsulateFields() { System.out.println(name); }

通过该对话框，可以选择要封装的字段，设置修饰符等。默认选择时，name字段的修饰符从public变成了private，这也就避免了外部类通过实例直接访问它。

重构后：

private String name = "zhangsan";private void testEncapsulateFields() { System.out.println(getName());}public String getName() { return name;}public void setName(String name) { this.name = name;}

23、Replace Temp With Query

24、Replace Constructor with Factory Method

作用：将构造方法替换为工厂方法

重构前：

public class MyClass { private String title; private String message; private String sure; private String cancel; public MyClass(String title, String message, String sure, String cancel) { this.title = title; this.message = message; this.sure = sure; this.cancel = cancel; }}public class RefactorTest { private void testReplaceConstructorWithFactory(Context context) { MyClass myClass = new MyClass("title", "message", "sure", "cancle"); }}

重构后：

public class MyClass { private String title; private String message; private String sure; private String cancel; private MyClass(String title, String message, String sure, String cancel) { this.title = title; this.message = message; this.sure = sure; this.cancel = cancel; } public static MyClass createMyClass(String title, String message, String sure, String cancel) { return new MyClass(title, message, sure, cancel); }}public class RefactorTest { private void testReplaceConstructorWithFactory(Context context) { MyClass myClass = MyClass.createMyClass("title", "message", "sure", "cancle"); }}

原先public修饰的构造函数，已经变成private了，MyClass类只能通过工厂方法来获取实例，而无法再直接new了。

25、Replace Constructor with Builder

作用：将构造方法替换为Builder方式

重构前：

public class RefactorTest{ private void testReplaceConstructorWithBuilder(Context context){ MyDialog dialog = new MyDialog(context,"title","message","sure","cancle"); }}public class MyDialog extends Dialog { private String title; private String message; private String sure; private String cancel; public MyDialog(@NonNull Context context) { super(context); } public MyDialog(Context context, String title, String message, String sure, String cancel) { super(context); this.title = title; this.message = message; this.sure = sure; this.cancel = cancel; }}

重构后：

public class RefactorTest { private void testReplaceConstructorWithBuilder(Context context) { MyDialog dialog = new MyDialogBuilder()  .setContext(context)  .setTitle("title")  .setMessage("message")  .setSure("sure")  .setCancel("cancle")  .createMyDialog(); }}public class MyDialogBuilder { private Context context; private String title; private String message; private String sure; private String cancel; public MyDialogBuilder setContext(Context context) { this.context = context; return this; } public MyDialogBuilder setTitle(String title) { this.title = title; return this; } public MyDialogBuilder setMessage(String message) { this.message = message; return this; } public MyDialogBuilder setSure(String sure) { this.sure = sure; return this; } public MyDialogBuilder setCancel(String cancel) { this.cancel = cancel; return this; } public MyDialog createMyDialog() { return new MyDialog(context); }}

看到这里，我们应该能够联想到AlertDialog类中的Builder了。将构造函数的形式，转变为了建造者模式的形式，这样不会拘泥于构造函数的参数个数，参数类型的限制，从而灵活设置属性。

26、Generify

作用：泛型重构，自动添加泛型的参数。

重构前：

private void testGenerify() { List list = new ArrayList(); list.add("one"); list.add("two"); list.add("three"); }

重构后：

private void testGenerify() { List list = new ArrayList(); list.add("one"); list.add("two"); list.add("three");}

27、Migrate

28、Internationalize（国际化）

29、Remove Unused Resources

作用：一直不用的资源

示例：1.jpg是一个没有被应用的文件。

在执行该重构方法后，1.jpg就被删除了。

以上是“AndroidStudio中代码重构菜单Refactor功能有哪些”这篇文章的所有内容，感谢各位的阅读！希望分享的内容对大家有帮助，更多相关知识，欢迎关注创新互联行业资讯频道！

本文题目：AndroidStudio中代码重构菜单Refactor功能有哪些-创新互联
转载来源：http://lswzjz.com/article/deidpj.html