2.4 Refactoring

One of the major advantages of using a good Java IDE like Eclipse is that it can let you rename and move Java elements around, and it will update all references to those items throughout your code automatically.

2.4.1 Renaming Elements

For example, take a look at the code in Example 2-6. Here, we've used code assist to create a new method to display a simple message, but we forgot to change the default name for the method that code assist supplied.

Example 2-6. The Ch02_06.java example

package org.eclipse.ch02;

/**
 * @author Steven Holzner
 *
 * To change the template for this generated type comment go to
 * Window>Preferences>Java>Code Generation>Code and Comments
 */
public class Ch0206 {

        public static void main(String[] args) {
                name( );
        }
        
        public static void name( ) {
                System.out.println("No worries.");
        }
}

This default name for the new method, name, is called in the main method, and it could be called from other locations in your code as well. How can you change the name of this method and automatically update all calls to it? Select name in the editor and then select the Refactor Rename menu item, opening the Rename Method dialog you see in Figure 2-20.

Figure 2-20. Refactoring a method

Enter the new name for the method, printer in this case, and click OK. When you do, the name of this method and all references to it will be updated throughout your code, including all code in the project, as you see here:

package org.eclipse.ch02;

/**
 * @author Steven Holzner
 *
 * To change the template for this generated type comment go to
 * Window>Preferences>Java>Code Generation>Code and Comments
 */
public class Ch0206 {

        public static void main(String[] args) {
                printer( );
        }
        
        public static void printer( ) {
                System.out.println("No worries.");
        }
}

We've also misnamed the class in this example—Ch0206, instead of Ch02_06. To rename the class, select Ch0206 in the editor and select the Refactor Rename menu item, opening the Rename Type dialog you see in Figure 2-21. Enter the new name, Ch02_06, and click OK to rename the class.

Figure 2-21. Refactoring a class

Clicking OK not only changes the name of the class in the code, it even changes the name of the class's file from Ch0206.java to Ch02_06.java, as you can see by checking the Package Explorer. Here's the new code:

package org.eclipse.ch02;

/**
 * @author Steven Holzner
 *
 * To change the template for this generated type comment go to
 * Window>Preferences>Java>Code Generation>Code and Comments
 */
public class Ch02_06 {

        public static void main(String[] args) {
                printer( );
        }
        
        public static void printer( ) {
                System.out.println("No worries.");
        }
}

In fact, we've unaccountably managed to misname the package as well when creating this example—org.eclipse.ch02 instead of org.eclipsebook.ch02. When you refactor it, the name is changed both in the Package Explorer and throughout your code:

package org.eclipsebook.ch02;

/**
 * @author Steven Holzner
 *
 * To change the template for this generated type comment go to
 * Window>Preferences>Java>Code Generation>Code and Comments
 */
public class Ch02_06 {

        public static void main(String[] args) {
                printer( );
        }
        
        public static void printer( ) {
                System.out.println("No worries.");
        }
}

As you can see, it's easy to rename Java elements in your code—Eclipse will handle the details, making the changes throughout your code automatically.

If you simply type over a Java element in your code, no refactoring happens. You've got to explicitly refactor if you want those changes to echo throughout your code.

2.4.2 Moving Elements

Refactoring works automatically across files as well. Say, for example, that you want to move the printer method to another class, Ch02_06Helper. To see how this works, create that new class now, which Eclipse will put in its own file, Ch02_06Helper.java. Then select the method you want to move, printer, by selecting the word "printer" in the declaration of this method. Next, select the Refactor Move to open the dialog you see in Figure 2-22. To move this method to the Ch02_06Helper class, enter the fully qualified name of that class, org.eclipsebook.ch02.Ch02_06Helper, in the dialog and click OK. This moves the printer method to the Ch02_06Helper class like this:

package org.eclipsebook.ch02;

/**
 * @author Steven Holzner
 *
 * To change the template for this generated type comment go to
 * Window>Preferences>Java>Code Generation>Code and Comments
 */
public class Ch02_06Helper {

        public static void printer( ) {
                System.out.println("No worries.");
        }
}

Figure 2-22. Moving a method between classes

And the call to the printer method is automatically qualified as Ch02_06Helper.printer back in the Ch02_06 class in the main method:

package org.eclipsebook.ch02;

/**
 * @author Steven Holzner
 *
 * To change the template for this generated type comment go to
 * Window>Preferences>Java>Code Generation>Code and Comments
 */
public class Ch02_06 {

        public static void main(String[] args) {
                Ch02_06Helper.printer( );
        }
        
}

2.4.3 Extracting Interfaces

You can also extract interfaces using refactoring. To see how this works, we'll create an interface for the Ch02_06Helper class (this class has the printer method in it). Convert printer from a static to a standard method by deleting the keyword static in the method declaration. Then select the name of the class, Ch02_06Helper, in the editor and select Refactor Extract Interface to open the Extract Interface dialog you see in Figure 2-23. Select the printer method to add that method to the interface, and then enter the name of the new interface—Ch02_06HelperInterface—and click OK.

Figure 2-23. Extracting an interface

Clicking OK creates a new file, Ch02_06HelperInterface.java, where the interface is declared:

package org.eclipsebook.ch02;

/**
 * @author Steven Holzner
 *
 * To change the template for this generated type comment go to
 * Window>Preferences>Java>Code Generation>Code and Comments
 */
public interface Ch02_06HelperInterface {
        public abstract void printer( );
}

The original class is now declared to implement this new interface, Ch02_06HelperInterface:

package org.eclipsebook.ch02;

/**
 * @author Steven Holzner
 *
 * To change the template for this generated type comment go to
 * Window>Preferences>Java>Code Generation>Code and Comments
 */
public class Ch02_06Helper implements Ch02_06HelperInterface {

        public void printer( ) {
                System.out.println("No worries.");
        }
}

Besides renaming and moving elements and extracting interfaces, there are other operations you can perform with refactoring, such as converting anonymous classes to nested classes, changing a method's signature, and converting a local variable to a class field. For these and other options, take a look at the items available in the Refactor menu.