Eclipse: Most useful refactorings [closed]

Answer 1

Rename - because giving things meaningful names is the best way to write self-documenting code. Shift+Alt+R

Extract method - whenever a method gets too long. Shift+Alt+M

Extract constant - because magic numbers are bad. Shift+Alt+T (refactoring menu, there's no direct shortcut).

Inline/introduce variable - to remove clutter from methods. Shift+Alt+I (inline), Shift+Alt+L (introduce)

Answer 2

"It's also worth reading this research: How do API evolve? A story of refactoring. by D. Dig and R. Johnson.

The authors noticed that 80% of the changes were refactorings and classified them. Here is the abstract ... "

80% of the BREAKING changes were observed to be refactorings. The refactorings themselves formed only 20 - 30% of the API changes..

Answer 3

The most popular refactorings have been stated, and I entirely agree with them.

Code formatter (Source, Format or Ctrl Shift F) is one of the features of the IDE I use very often. True, it is not refactoring, but it improves code readability while maintaining your coding style: simply head to Preferences, Java, Code Style, Formatter and tell Eclipse how you want your code to look!

Generate Getters and Setters is also a feature I find to save time when writing Java beans.

Answer 4

Eclipse has perhaps the least refactorings for all the popular IDEs. You might consider Netbeans or IntelliJ (Community edition is free). Conversely Eclipse has possibly the best debugger. ;)

I use refactoring as I write the code (which I have found speeds up writing by about 15%) so IntelliJ's ability to refactor code which does not compile very useful for me. The other IDEs may support this now (does any one know?) I find IntelliJ's smart complete is a fair bit smarter as well.

I have tested retyping a files from printout (originally written in eclipse) and found I used 30% less keys and 50% less mouse movements when typing the file with IntelliJ (compared with Eclipse) I would estimate Netbeans to be somewhere in the middle.

Answer 5

My favorites are:

1) Rename - It works on method names, variable names, class names, fields-- really anything with a name.
2) Convert Anonymous Class to Nested - Helps with debugging, lets you reuse logic (such as a comparator) that you only thought that you'd use in one place.
3) Convert Member Type to Top Level - Frequently after making an anonymous class into a nested class I discover that the class is useful elsewhere. This refactoring is perfect then.

Answer 6

My favorites:

1. Renaming
2. Pull up/Push Down
3. Extract Method