Shulou(Shulou.com)06/03 Report--

This article mainly introduces what the AndroidStudio code refactoring menu Refactor functions have, the article is very detailed, has a certain reference value, interested friends must read it!

There is a "Refactor" drop-down menu in the main menu bar of AS. Click on the drop-down menu and you will see the following interface. Each item in the menu is an automatic implementation for code refactoring. With so many functional items, we can see the powerful function of AS in code refactoring. Let's introduce these items one by one. In addition, you can right-click in the editing interface, and you can also find "Refactor" in the pop-up menu.

1 、 Refactor This

Function: reconstruct the current. Doing this displays the feasible refactoring method for the current cursor selection.

Example: after selecting the class name "RefactorTest" and operating "Refactor This", a list of executable refactoring methods is displayed, and the corresponding method can be executed by selecting a number.

2 、 Rename

Function: rename the cursor selection. You can rename not only the member variables in the class, but also the file name, package name, and so on. All the places associated with it in Module will be modified together instead of manually.

Shortcut key: Shift + F6

Example: enter the modified name in the red box and press enter.

3 、 Rename File

Function: modify the file name of the file displayed in the current editing interface. It is equivalent to selecting the file with the mouse and executing the "Rename" method.

Example: enter a new file name in the dialog box that appears. You can choose to modify the scope in the option box below, where the file is referenced, in the comments, and in the string.

4 、 Change Signature

Function: to modify the signatures of methods, classes, and constructors is to modify some of the selected properties.

Shortcut key: Ctr l + F6

Example: the following shows a method before refactoring, the refactoring process, and the situation after refactoring (take modifying a method signature as an example).

Before refactoring:

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

After the method name is selected, the following dialog box pops up after the refactoring method is executed, where you can modify various properties of the method, add / remove parameters, adjust the order of parameters, add / delete exceptions, and so on.

After refactoring:

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

5 、 Type Migration

Function: type migration, that is, to modify the variable data type, or the return type of the method. The previous introduction to the file name, package name, variable name and so on to modify, here to modify the type.

Shortcut key: Ctrl + Shift + F6

Before refactoring:

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

Select the type you want to modify, execute the refactoring method, a dialog box will pop up, edit the type as needed, and select the scope of action. Within the specified range, all associated with the variable will be modified.

After refactoring (due to the change from int to String, you also need to manually modify the variable value):

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

6 、 Make Static

Purpose: add the static keyword to an inner class or method. The example is relatively simple, so there is no demonstration.

7 、 Convert To Instance Method

Function: convert to instance method, that is, the static method removes the static keyword.

8 、 Move

Function: move files to the specified path

Shortcut key: F6

9 、 Copy

Purpose: copy a current file in the specified package

Shortcut key: F5

10 、 Safe Detele

Function: safe deletion, which can be used to quickly delete methods / fields, etc., and delete the references associated with them.

Shortcut key: Alt + Delete

11 、 Extract

(1) Variable

Function: extract variables. This is often used when dealing with longer expressions, extracting a seemingly long and complex expression as a variable representation.

Shortcut key: Ctrl + Alt + V

Before refactoring: we often see this kind of code

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

The information expression to be printed on the second line is too long and you want to extract it separately and represent it as a variable. In this example, when the mouse hovers over the second line "getAaaaaaaaaaaaaaaaaaaaaaaaaaaAge" and executes the refactoring method, the following red box part of the dialog box pops up, showing the extractable part related to the selected expression, and you can select the part to be extracted as needed.

After refactoring:

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

Function: extract a constant and extract the value in the expression as a constant.

Shortcut key: Ctrl + Alt + C

Before refactoring:

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

After refactoring:

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

(3) Filed

Function: extract fields and extract local variables into global variables.

Shortcut key: Ctrl + Alt + F

Before refactoring:

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

After refactoring:

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

(4) Parameter

Function: extract local variables as parameters of the method.

Shortcut key: Ctrl + Alt + P

Before refactoring:

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

After refactoring:

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

(5) Functional Parameter (functional parameter) Ctrl + Alt + Shift + P

(6) Parameter Object

Function: extract the parameter into an object. The main purpose of this function is to extract these parameters and pass them in as a Bean instance when there are many parameters.

Before refactoring:

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;}

After refactoring:

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

Function: extract as a method

Shortcut key: Ctrl + Alt + M

Before refactoring:

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

Execute the reconstruction method after lines 2 ~ 5 are selected by the mouse cursor

After refactoring:

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

Purpose: extract the selected content into a method and extract it into a separate class. Very similar to "Method", the difference is where the extraction method is placed at the end.

Before refactoring:

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

After refactoring:

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

Function: extract as a proxy class.

Before refactoring:

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

After refactoring:

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

Function: extract as an interface.

Before refactoring:

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

Public-decorated methods can only be extracted into the interface.

After refactoring:

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

(12) Superclass

Purpose: to extract the specified content into the parent class.

Before refactoring:

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

After refactoring:

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

12 、 Inline

Function: convert to an inline, method chain call.

Shortcut key: Ctrl + Alt + N

Before refactoring:

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 aq2 + baux3;}

After refactoring:

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

Originally, you need to call a method, but after refactoring, you copy the code in the method directly. Because all inline is selected above, and the method is deleted, the add method is also deleted.

13 、 Find and Replace Code Duplicates

14 、 Invert Boolean

Purpose: converts the Boolean value and converts the current false/true value to the opposite value.

Before refactoring:

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

After refactoring:

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

15 、 Pull Members Up

Role: move members of a subclass up to the parent class.

Before refactoring:

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

After refactoring:

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

16 、 Push Members Down

Function: move the members of the parent class down to the subclass, which happens to be the reverse operation of "Pull Members Up".

Before refactoring:

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

After refactoring:

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

Purpose: use proxies instead of inheritance. In java, the use of composition rather than inheritance is promoted.

Before refactoring:

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 ();}

After refactoring:

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 ();}}

This section is a bit like the relationship between Context,ContextWrapper,ContextImpl classes in Android.

19 、 Remove Middleman

Function: to remove the middleman is to remove the intermediate process.

Before refactoring:

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);}

After refactoring:

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;}

Comparing the pre-refactoring with the post-refactoring, you will find that the action of adding book has changed from being performed by BookManager's addBook method to being directly executed by mBookList. This addBook is the MiddleMan, which seems redundant and can be optimized. In fact, after optimization, it becomes an inline mode, which can be compared with the "Inline" mentioned earlier.

20 、 Wrap Method Return Value

Function: encapsulate the return value

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

After refactoring:

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

Function: convert an anonymous inner class to an inner class.

Before refactoring:

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

After refactoring:

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

Function: encapsulates fields that are used to generate Getter/Setter

Before refactoring:

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

Through this dialog box, you can select fields to encapsulate, set modifiers, and so on. When selected by default, the modifier of the name field changes from public to private, which prevents the external class from accessing it directly through the instance.

After refactoring:

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

Function: replace the constructor with the factory method

Before refactoring:

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");}

After refactoring:

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");}}

The original public-decorated constructor has become private, and the MyClass class can only get the instance through the factory method, and can no longer new directly.

25 、 Replace Constructor with Builder

Function: replace the constructor with Builder mode

Before refactoring:

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;}}

After refactoring:

Public class RefactorTest {private void testReplaceConstructorWithBuilder (Context context) {MyDialog dialog = new MyDialogBuilder () .setContext (context) .setTitle ("title") .setMessage ("message") .se tSure ("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);}}

Seeing here, we should be able to think of Builder in the AlertDialog class. Change the form of the constructor into the form of the builder pattern, so that it will not rigidly adhere to the number of parameters of the constructor and the limitation of the parameter type, so as to set the properties flexibly.

26 、 Generify

Function: generic refactoring, automatically adding generic parameters.

Before refactoring:

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

After refactoring:

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

27 、 Migrate

28. Internationalize (internationalization)

29 、 Remove Unused Resources

Role: resources that have been unused

Example: 1.jpg is a file that has not been applied.

After the refactoring method is executed, the 1.jpg is deleted.

These are all the contents of the article "what are the functions of code refactoring menu Refactor in AndroidStudio". Thank you for reading! Hope to share the content to help you, more related knowledge, welcome to follow the industry information channel!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.