For example, there’s almost no reason to ever want to step into Spring’s code or proxy classes (other than to learn more about them or maybe debug a potential bug in Spring). And normally I’m not interested in Java util classes (eg. ArrayList). This also goes for Hibernate, Apache Commons, Google and many other external libraries.

Fortunately, Eclipse makes it easy to specify which classes to skip by allowing step filters. This makes it easier to focus on your own code and also keeps your editor area clean since Eclipse won’t be opening classes in separate editors all the time.

Enable Step Filters

To use step filters, the first step is to enable it. Eclipse comes with some default filters so let’s start by enabling them all. This will filter all Java classes (ie. java.*) and all Sun classes (ie. sun.*).

1. Go to Window > Preferences > Java > Debug > Step Filtering.
2. Select the option Use Step Filters.
3. Click Select All to enable all the filters.
4. Leave the other options below the filter list as-is.

Here’s an example of what it should look like:

NB: Even with step filters enabled, you can still set breakpoints within any of these classes (if you have the source) and Eclipse will still stop at the breakpoint. Step filtering only affects the way that Step Into works.

Also note that Eclipse will still step into your classes if they’re called from the ignored classes. For example, when you call Collections.sort(List, Comparator) and pass your own Comparator implementation, Eclipse will not step into the sort code, but it will step into your Comparator when it’s called by the sort code.

If you want to change this behaviour (ie. prevent Eclipse from stopping in your method), then deselect Step through filters. However, I’d recommend only doing this if you’ve tried out the default, because most times you’ll probably want to step through your own code.

The next step is to create some step filters of your own.

Creating your own step filters

Once you’ve enabled step filters, all you have to do is add the classes you want to filter. Let’s assume that we want to ignore all classes from Spring, especially proxy classes.

1. If you’re not there already, go to Window > Preferences > Java > Debug > Step Filtering.
2. Click Add Filter… A dialog should appear prompting you to enter a pattern.
   
3. Enter a regular expression for the classes you want to filter in the Pattern to filter field then click Ok. In our example, enter org.springframework.* (see image below). It’s easier to specify the top level package name with an asterix at the end.
4. Add another filter with the pattern $Proxy* to skip over Spring proxy classes (eg. when using Spring Transactions).
5. Click Ok on the Preferences dialog when you’re done.

Here’s what the step filter pattern dialog should look like:

Now when you use the debugger, you won’t be taken into Spring classes when you use Step Into (F5).

Some ideas for custom filters

In addition to the Spring classes, you might also want to consider adding the following common libraries to your step filters to make debugging easier:

• org.apache.*
• org.hibernate.*
• com.google.*
• org.eclipse.*
• org.osgi.*

The last two are especially useful if you’re doing Eclipse RCP and/or OSGi development.

Related Tips

• Setup Eclipse breakpoints to stop only under certain conditions
• Run/debug a class in Eclipse as a JUnit test or Java app with a single keystroke
• Generate static imports in Eclipse on autocomplete for JUnit Assert, StringUtils and others
• Always run/debug the last launched class instead of the selected one in Eclipse

Share This Tip

You could use the mouse wheel and scroll ferociously until you eventually find the method or you could even use Page Down/Page Up on your keyboard. But these methods can be time-consuming and haphazard, especially when the class has lots of methods or they’re scattered in an arbitrary order.

Luckily, Eclipse has a number of fast and easy ways to help you navigate methods in a class, especially using the keyboard. I’ll discuss some of those keyboard shortcuts and also which ones to use when.

Quick Outline

The Quick Outline is basically a scaled-down popup version of the Outline View. The main advantage over the Outline View is that it has a search box that allows you to search for a method.

Here’s how to use the Quick Outline:

• Press Ctrl+O from anywhere within the class.
• Type a search term in the search box and Eclipse will just show all methods that match the search term. By default Eclipse does an exact match search, but you can use wildcards.
• Once you see the method you’re interested in, press Down to select the method (if it’s not selected already).
• Press Enter once the method is selected. Eclipse will take you directly to the method’s declaration.

This is an example of the popup for Java’s ArrayList.

Searching for *rem will search for all method names that contain the word rem. Here’s an example:

Notes:

• Sort the view using the the down arrow menu in the top right corner. It makes it easier to find methods by scanning.
• Resize the Quick Outline popup to see more methods. Eclipse remembers the size of the popup for the next time you open it.

Next Member & Previous Member

Another way to move between methods is to use two features called Go To Next Member and Go To Previous Member.

When you press Ctrl+Shift+Down, Eclipse moves the cursor to the next method in the class. Pressing Ctrl+Shift+Up moves to the previous method.

Here’s a video to give you a quick example of how these shortcuts work:

This shortcut works best if you’re already positioned in a method or if the class has few fields. That’s because to Eclipse a member can either be a method or a field. If you’re at the top of the class, you have to move through all the fields before you actually start moving through the methods themselves, a time-consuming process especially for bigger classes with lots of fields.

It helps to generate getters and setters at the bottom of the class because you don’t have to navigate through them to get to the useful methods.

Open Declaration

If you’ve got lots of private methods in your class then Open Declaration might be the best way to navigate between them.

When you’re positioned on a method call and press F3, Eclipse takes you directly to the definition of that method. For example, if you’re busy in the method process() and your cursor’s positioned on initProcessing(), pressing F3 will take you directly to the declaration for that method further down the class.

public void process() {
    //Do things...
    initProcessing();
    //...
}
...
private void initProcessing() {
    //Init something...
}

This feature works very well with Alt+Left (Backward History). See the section below for more details about the Backward History.

Navigating Back to a Previously Viewed Method

While browsing code, you’ll often want to return to the previous method you were viewing once you’re done viewing the method it calls.

To do this, use Alt+Left (Backward History) to move back to the last navigation point. This feature isn’t specific to just methods, but also works for navigating between previously visited editors. But it works great if you’ve just been browsing methods within a class.

Quick Mentions

• Eclipse’s Outline View also allows easy navigation but mostly with the mouse. You could navigate to the view using Alt+Shift+Q, O, and you can move to methods by typing their first letter, but I’ve found the Quick Outline to be more keyboard friendly. Also, the Outline View doesn’t support wildcard searches.
• You can also use Eclipse’s Call Hierarchy (Ctrl+Alt+H) especially if you’re trying to understand the flow of methods in a class and move between them easily. Knowing how to navigate between views and editors with the keyboard helps a lot since you’ll be moving between the Call Hierarchy view and editors a lot.

What Should I Use When?

• Use Next/Previous Member shortcut if the class is small or you have a good idea of where other methods are in relation to the current method (eg. are they above/below the current method).
• Use the Quick Outline if you don’t know the class too well or there are lots of methods in the class.
• Use Open Declaration if you’re moving between many private methods of the class. It’s normally the fastest way to move to another private method in the class, but only if you’re already positioned in a method that calls it.

Related Tips

• Find all classes that override/reimplement a method
• Jump to the start and end of methods, loops, blocks and XML tags
• Select entire strings and methods in Eclipse with a single keystroke
• Add, remove and reorder a method’s arguments instantly across multiple classes in Eclipse
• Quick ways to navigate Eclipse editors using the keyboard
• How to manage keyboard shortcuts in Eclipse and why you should

Share This Tip

But managing getters and setters is a time-consuming effort. Creating a getter/setter for 5 fields in a class can take minutes, renaming one is error-prone and deleting one is just plain inconvenient.

There are options like Project Lombok (that implicitly creates getters/setters without the need to code them) and you could avoid getters/setters altogether by redesigning your classes.

But these options aren’t always available, so it’s a good thing Eclipse has some handy features for managing getters and setters. Combined with the ability to generate constructors based on fields, you can get the boilerplate code out of the way in seconds and get on with the real coding.

Generate getters and setters

To generate getters and setters, do the following:

1. Create the fields you want in the class then press Alt+Shift+S, R. A dialog will pop up allowing you to choose the fields you want to generate getters and setters for.
2. Click Select All to create getters/setters for all fields. Of course you can choose individual fields as required.
3. Change Insertion point to Last Member. This tells Eclipse that you want to put the methods at the bottom of the class. This is normally the best option for me as I want them out of the way.
4. Click Ok. Eclipse will create the getters and setters for you.

Here’s an example of what the dialog should look like.

Note: By default, Eclipse doesn’t allow you to create a setter for a final field – the setter just doesn’t appear in the dialog. This can be a nuisance, especially if you’ve enabled autoformatting to make fields final where possible. To bypass this restriction, enable the checkbox Allow setters for final fields on the dialog. The setter for the field will now appear in the dialog. Once you click Ok, Eclipse will remove the final keyword from the field and generate the setter. Eclipse also remembers this setting.

Another way to add just a single getter/setter is to position your cursor anywhere in the class (outside any method), start typing either “get” or “set” and press Ctrl+Space. The options on the autocomplete menu will include any getters/setters of fields that don’t have any defined yet. This is a quick way to create a single getter/setter but isn’t geared for bulk creation.

Here’s an example of how the autocomplete looks:

Rename getters and setters

The easiest way to rename getters/setters is to use the Rename refactoring.

Place your cursor on the field name (anywhere in the class, not just the declaration) and press Alt+Shift+R. If you’re using in-place rename (the default), then just rename the field, press Enter and Eclipse will rename the corresponding getters and setters as well.

If you’ve chosen to use the classic Refactor dialog (see note below) then make sure you enable Rename getter and Rename setter on the Rename dialog.

Note: You can choose to do renaming using the traditional Rename dialog by going to Window > Preferences > Java and unchecking Rename in editor without dialog. I prefer using the Rename dialog as it highlights the whole name by default making it easier to overwrite and I have the option of not renaming the getters and setters if I don’t want to. The Eclipse default these days is to use the new in-place renaming.

Although Eclipse will rename the getter/setter, it won’t rename the argument passed to the setter method. If you want consistency, you can navigate to that method (eg. using Ctrl+O) and rename the argument yourself.

Delete getters and setters

Deleting getters and setters isn’t as straightforward as just deleting the field in the editor. However, you can delete a field and its getters/setters from the Outline view.

Open the Outline view (Alt+Shift+Q, O), select the field you want to delete and press Delete (or right-click, Delete). Eclipse will ask you whether you want to delete the getters/setters as well. Just choose Yes To All and they will be removed.

You need to have fields visible in the Outline view to use this feature (ie. untoggle the Hide Fields button ).

You can select multiple fields simultaneously. And you can delete individual getters/setters (excluding the field) by just selecting the getter/setter and pressing Delete.

Related Tips

• Generate class constructors in Eclipse based on fields or superclass constructors
• Add, remove and reorder a method’s arguments instantly across multiple classes in Eclipse
• Jump to the start and end of methods, loops, blocks and XML tags
• The fastest ways to navigate views in Eclipse using the keyboard
• Convert nested/anonymous classes into top level classes using Eclipse refactoring

Share This Tip

Luckily, Eclipse has a number of ways to open editors easily using the keyboard. Couple these with oodles of keyboard shortcuts to navigate between editors once you’ve opened them, and you’ve got enough tools to stay away from the mouse and make coding go a lot faster. I’ll discuss some of the more efficient options and then give a summary of when to use which method.

Open Resources

Probably the most effective way to open a file in an editor is by using the Open Resource functionality. If there’s one feature you want to use every day, it’s this one.

When you press Ctrl+Shift+R, you get a dialog that allows you to search all the files currently in your workspace. You can find any files such as classes, XML, property, HTML and other files. Here’s an example:

To find a file, start typing its name and once it’s selected, just press Enter. Eclipse filters the files as you type, so you can immediately see when your file appears in the list. You can also move through the list by pressing the Up and Down arrows, even if the search box has the focus (ie. you don’t have to use Tab to move to the list).

The search box supports wildcards, so you could type *Dao to search for all files that contain the word Dao. If you don’t include wildcard characters (* and ?) then Eclipse will do a direct match of the string you enter to the files in your workspace. The search isn’t case-sensitive, though, so you don’t have to worry about camel case.

Open Types

When you press Ctrl+Shift+T, you get a dialog similar to the Open Resources dialog called the Open Types dialog. Here’s an example:

Like the Open Resource dialog it shows a list of resources that match your search text. However, it only shows Java types (eg. classes, enums, interfaces, etc). It doesn’t show any other files in the workspace such as HTML or XML files. The other difference is that it shows Java types both from your workspace and referenced libraries, including 3rd party and Java library classes.

Similar to the Open Resources dialog, this dialog also supports wildcard characters but goes one step further by supporting camel case searches. For example, if you want to search for NullPointerException, you can type NPE and Eclipse will filter the types based on their case-sensitive camel case names. Note that typing Npe will not return the same results, as the camel cases are different.

The Open Types dialog is ideal for quickly opening 3rd party classes or built-in Java classes such as ArrayList or String.

Open Declaration & Implementation (Quick Type Hierarchy)

If you press F3 (Open Declaration) while your cursor is on a Java type such as a class, method or field, Eclipse will open the type’s declaration (if it’s not opened yet) and navigate you to the definition. In the example below, pressing F3 on the method length() will open String.class and take you to the implementation of String.length().

String name = "";
if (name.length() > 0) {...}

But Open Declaration isn’t always enough. For example, if you call the method on an interface, eg. the add() method of List, F3 will take you to the interface List and position you on the add() method. But often you actually want to go to one of the implementations of add(), eg. ArrayList.add().

In that case you can view the Quick Type Hierarchy (Ctrl+T) on the method and choosing the specific implementation you want. I discuss Quick Type Hierarchy in more detail in how to find all methods that override a certain method of a class, but here’s a quick example of what you’ll see:

Bonus Tip: To access the mouse equivalent of these 2 features, hold down Ctrl and hover over the element you want. Eclipse will underline it, allowing you to click on the element. If the element doesn’t have additional implementations, Eclipse will take you automatically to its sole declaration. If there are one or more implementations, you’ll get a popup menu offering you the option of opening either the declaration or implementation, eg:

Quick mentions

Here are some more features that you may find useful from time to time.

• Open Super Implementation: When you’re positioned in a subclass that overrides a superclass method, you can choose Navigate > Open Super Implementation from the application menu to go to the super’s method. You can configure a shortcut for this by looking for the command Open Super Implementation in the Keys preference dialog. Alternatively, press Alt-N, S to invoke it via menu mnemonics (although this is not as reliable as configuring a shortcut).
• Open Type Hierarchy: The Type Hierarchy shows you a tree representing a class’s hierarchy (ie. superclasses and subclasses). Just press F4 while positioned on a class name and the Type Hierarchy view will open. From there you can move directly to certain classes and methods in the type hierarchy.
• Recent Files: If you’ve accidentally closed a file you still need, just press Alt+F and then the number of the file as indicated on the File menu. Eg. Alt+F, 1 will take you to the most recently opened file.
• Show In: By using shortcuts to open editors, you don’t need to rely on the Package Explorer that much anymore, so it’s a good candidate for becoming a fast view, which could save you lots of screen space. But if you want to open the current editor in the Package Explorer, just press Alt+Shift+W, P, and Eclipse will instantly navigate to the file in the Package Explorer.

Which one should I use when?

If you don’t have enough time to learn all of these, here’s a quick guide on where to start and when to use them.

• For fast, everyday, general usage, use Open Resource. I use it to open all resources, even Java types because the list only shows classes in my workspace which makes the search go faster. Definitely worthwile to learn.
• If you’re browsing code (eg. during a code review or to debug it) then Open Declaration and Quick Type Hierarchy are very useful especially when combined with Open Resource.
• If you want to view class hierarchies (eg. subclasses or superclasses), use Open Type Hierarchy, Open Super Implementation or Open Quick Hierarchy. They’re not only a good way of opening resources but also of getting an idea of your class hierarchy and hence your design.
• If you’re trying to open 3rd party classes or Java built-in classes, first try using Open Declaration (F3), because the chances are you’ll probably be in the part of the code that uses these classes. However, if you’re not anywhere near the code, use Open Type.

Also keep in mind that you can change the keyboard shortcut on any of the features above by checking out how to manage keyboard shortcuts and using the appropriate command names to search for and modify the key.

Related Tips

• Quick ways to navigate Eclipse editors using the keyboard
• The fastest ways to navigate views in Eclipse using the keyboard
• Switch and close editors faster with the keyboard using Eclipse’s Quick Switch Editor
• Find all classes that override/reimplement a method
• Instantly show a class/file in the Package/Project Explorer in Eclipse
• How to manage keyboard shortcuts in Eclipse and why you should

Share This Tip

Although useful at times, this becomes extremely annoying after a while, especially when you’re using your mouse to browse some code. Popup after popup of unwanted information keeps obscuring your view of the code, leading to some lengthy expletives and big productivity loss. It’s useful information, but not every time all the time, almost like your car’s GPS giving you directions to 10 different places at once while you’re still parked in the driveway.

Luckily there is a way to alleviate the problem and all it takes is changing some preferences in Eclipse. We don’t want to completely disable tooltips (they can be useful), so I’ll show you how to tell Eclipse to bring up the tooltips only when you request them.

Show tooltips only on request

To tell Eclipse to only show tooltips on request, do the following:

1. Go to Window > Preferences > Java > Editor > Hovers.
2. Select the Source item in the list. Make sure the entire row is highlighted and that the checkbox is selected.
3. Move focus to the Pressed key modifier while hovering field, positioning the cursor at the end of the default value Shift. Press and release Ctrl. The value should now read Shift+Ctrl. If you made a mistake, just clear the field by pressing Backspace or Delete and try again.
4. Select the Combined Hover item in the list.
5. Move focus to the Pressed key modifier while hovering field and press Shift. The value should now read Shift.
6. Click Ok to accept the changes.

The preferences should look something like this:

You should now notice the following:

• If you want to show the Javadoc or the declaration of some element hold down Shift while hovering over the element.
• Variable values won’t popup automatically anymore. To show a variable’s value in debug mode, press Shift and hover over the variable. This is probably the only time when it’s a bit of a hassle to press Shift, but the pros totally outweigh the cons here as I view variable values a lot less than the number of times annoying tooltips appear.
• If you want to show a quick preview of a method’s code, press Ctrl+Shift and hover over the method. This is a nice feature combined with the tooltip enrichment Eclipse provides, so you can view a method’s code in a scrollable tooltip without having to navigate to the method and back again.

Other options – configure, disable or use the keyboard

You can, of course, choose your own modifier keys in Preferences, but these are the ones I found that work the best, especially given that Ctrl and a click is a way to go to an element’s declaration or implementation in Eclipse. I’ve found Shift to conflict the least with existing features and easy enough to use on a frequent basis. Keep in mind that 2 hovers can’t share the same modifier key (which is why we reassigned the Source hover to use Shift+Ctrl).

You can also disable tooltips completely by deselecting the Combined Hover checkbox in the preference above, but I’ve found the Shift key to be a nice middle ground so keep it enabled.

To get similar information using the keyboard, press F2 while the cursor’s positioned on the code. To show variable values in debug mode, press Ctrl+Shift+D. A nice tip if you’ve disabled tooltips completely.

Related tips

• Add comments and Javadocs in Eclipse with a single keystroke
• Always run/debug the last launched class instead of the selected one in Eclipse
• Use Fast Views to maximise screen space
• Also check out many other preferences you can configure and annoyances you can remove to make Eclipse easier to use.

Share this tip

JButton button = new JButton();
button.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
        // ... Do something useful
    }
});

But there comes a point when the nested class becomes so bulky that code becomes unreadable. And sometimes you want to reuse the same class in another place – something that’s difficult with anonymous inner classes.

The answer would be to change the nested class into a top level public class (or a first-class citizen, if you like) that exists in its own file (eg. SomethingUsefulActionListener.java). But doing this manually can take a lot of time and is error-prone.

Eclipse has a couple of refactorings and quick fixes that help to make the job a lot easier. Converting an anonymous inner class to a top level class requires two refactorings only and will take you a couple of seconds instead of minutes. A (named) inner class takes only one refactoring. And passing arguments to the new class is also easy if you use some of Eclipse’s Quick Fixes.

Convert the anonymous inner class into a top level

Converting an anonymous inner class into a top level class takes 2 main refactorings: Convert it to a nested class and then convert the nested class to a top level class. If you have a nested class (ie. a named inner class), then just start at step 4.

Here are the instructions, but there’s also a video below with a quick example.

1. Convert the anonymous inner class to a nested class by standing on the anonymous class’ constructor and choosing Refactor > Convert Anonymous Class to Nested… (or Alt-T, O). A dialog prompting for the nested class details will appear.

2. Enter a name for the new nested class, select public as the visibility and deselect Declare the nested type as final.

3. Click Ok. Eclipse will create a new nested class inside the enclosing class and leave the constructor call where the anonymous class used to be declared.

4. Now convert the nested class into a top level class by standing on the class name and choosing Refactor > Convert Member Type to Top Level… (or Alt-T, V). A dialog prompting for the enclosing instance name will appear.

5. (Optional) If you want to access the enclosing class within your new class, then enter a name for the field that will be assigned to the class. I normally leave this blank.

6. Click Ok. Eclipse will create the new class (UsefulAction.java) and move it to a new file in the same package.

Here’s a quick video to show you how easy this is. In the example, we’ll convert an anonymous inner ActionListener class to a class called UsefulAction.java.

Passing arguments from the enclosing class into the new class

What about when the nested class accesses fields in the enclosing class? How do you easily get private fields from the enclosing class into the new top level class?

There isn’t a one-shot way to do this, but there are techniques to make it go a bit faster. One trick is via the following steps:

1. First make sure you’ve created a named nested class (steps 1-3).
2. Copy and paste the relevant private fields of the enclosing class into the nested class.
3. Automatically generate a constructor for the nested class based on the fields you just copied (Alt+Shift+S, O).
4. Navigate to the constructor error (Ctrl+.) where the nested class is instantiated and add the fields to the constructor.

The easiest way to see how this works is to watch the following video. In the example, I’ll pass the fields name and address to the new class.

Related Tips

• Instantly show a class/file in the Package/Project Explorer in Eclipse
• Generate class constructors in Eclipse based on fields or superclass constructors
• Navigate and fix errors and warnings in a class with Eclipse keyboard shortcuts
• Extract constants from strings and numbers with Eclipse refactorings
• Add, remove and reorder a method’s arguments instantly across multiple classes in Eclipse
• Some more tips on refactoring faster and using quick fixes more effectively.

Share This Tip

That’s why there are a number of ways to navigate between editors in Eclipse using only the keyboard. Combined with the ability to quickly navigate views using the keyboard, it’s an easy way to work faster and almost get rid of the mouse (reducing company spending… well, slightly).

Cycle through open editors

This is probably the fastest way to navigate between editors in most cases. When you press Ctrl+F6 (Next Editor), a popup appears with a list of  all open editors. The list is sorted in order of most recently used, so if you press Ctrl+F6 and release it immediately, Eclipse will take you to the last active editor. Press Ctrl+Shift+F6 to reverse the direction.

This is a great way of jumping between 2 editors, eg. to read something in the one while typing in the other. Here’s an example showing what happens when you press Ctrl+F6 while on Template.java.

I strongly recommend mapping the Next Editor command to Ctrl+Tab in addition to (or instead of) Ctrl+F6. Just make a binding for the command Next Editor under Window > Preferences > General > Keys – see how to manage your keyboard shortcuts for details on how to do this. But why remap the key? Well, not only is it a lot easier and faster to press (you can use one hand to do this), it’s also standard for most Windows applications so you may already be familiar with it. It makes switching editors 5 times faster (yes, statistically proven).

Another way of using cycling is to press Ctrl+F6 and then press F6 repeatedly while holding down Ctrl. Eclipse will highlight the next editor in the list until you release Ctrl, after which it will activate the highlighted editor. This is a good way to navigate a short list of editors (eg. 5-10 open editors) but can get a bit cumbersome when there are more editors.

Quick Switch Editor

Another fast way of navigating editors is via the Quick Switch Editor functionality. I’ve posted another tip dedicated entirely to this feature, so won’t discuss it in detail here but just give a brief rundown of how it works. Basically, it’s great when you have a large number of editors open.

By pressing Ctrl+E, you can get a list of all open editors. This list is searchable  and even supports wildcards, which is why it’s great for cases where you have a large number of editors open. The Quick Switch Editor is also flexible in that it supports closing editors directly without activating them. Here’s an example of what you’ll see:

Move sequentially from one editor to the next

You can also move between editors in the order of their tabs in the editor area. To move to the next editor just press Ctrl+Page Down, while Ctrl+Page Up takes you to the previous editor.

In the example below, when you press Ctrl+Page Down, Eclipse will activate the editor Engine.java, assuming that we’re currently positioned on TestSomeUtils.java. Repeating this will take you to ClientDataSource.java.

Moving between editors sequentially is sometimes useful, but the big drawback of it is that it doesn’t consider which editors you’ve been working on recently (in my experience, the more likely case) so can be slow in those scenarios.

Bonus Tip: If you’re wondering how to move between different pages of a multipage editor (eg. plugin.xml below), then just press Alt+F7 to move to the next page and Alt+Shift+F7 for the previous page. Multipage editors used to “break” Ctrl+Page Down navigation in previous versions of Eclipse because they’d hijack the key preventing you from moving to the next editor. This has changed in Eclipse 3.5.

Which one should I use when?

Here are some recommendations on when to use what to work most efficiently:

• If you want to quickly move between the editors you’ve used recently, use editor cycling . This is such a common requirement, that this is probably the editor navigation I use the most. Remember to create an additional binding for it to Ctrl+Tab – it works a lot faster.
• If you’ve got a large list of open editor (eg. 10+) then use the Quick Switch Editor. Editor cycling is a decent choice up until about 10 editors.
• If you just quickly want to browse the editors one by one to scan through them (eg. you have a couple of XML files you want to scan briefly), then use the sequential navigation.

In summary, focus on learning editor cycling, then using the Quick Switch Editor. After that, pick from some of the others depending on how you work.

Quick mentions

Here are a couple of other ways to navigate editors, but, although they do come in handy sometimes, they may not be as efficient as the ones above.

• While editing and navigating through editors, you’ll often want to go back to the last place you were editing. Just press Ctrl+Q and Eclipse will take you directly to the exact location where you were last editing. This way you don’t need to trace your steps to get back to your last edits. Even comes in handy when you have to scroll through the same file then go back to the last edit.
• Use Eclipse’s History functionality to move back to previous editors, similar to using a browser history. Press Alt+Left to go back to the previous editor and Alt+Right to go forward. This is useful when switching back and forth between 2 different editors or when you want to an editor that you’ve closed, as the history also reopens closed editors.
• An overlooked-but-useful Eclipse feature is the most recently used list under the File menu. Just press Alt+F, 1 (or any other number that’s indicated in the menu) to go to the most recently opened editor. This is useful when you’ve accidentally closed an editor you still want to use.

Related Tips

• The fastest ways to open editors in Eclipse using the keyboard
• Switch and close editors faster with the keyboard using Eclipse’s Quick Switch Editor
• Split and view the same editor side by side in Eclipse
• The fastest ways to navigate views in Eclipse using the keyboard
• How to manage keyboard shortcuts in Eclipse and why you should
• Here are more ways to navigate faster and use editors more efficiently in Eclipse.

Share This Tip

Or you could use the quick way of adding a comment with a single keystroke no matter where the cursor’s positioned in the statement.

The same goes for Javadocs – there are just too many things to type before you can start commenting the good stuff. That’s why Eclipse also has a shortcut that let’s you add Javadoc to a field, method or class.

Keyboard shortcuts for comments and JavaDocs

Here are the keyboard shortcuts for manipulating comments.

Bear the following in mind when using Add Javadoc comment (Alt+Shift+J):

• To add a comment to a field, position the cursor on the field declaration.
• To add a comment to a method, position the cursor anywhere in the method or on its declaration.
• To add a comment to a class, the easiest is to position the cursor on the class declaration. Also works if you’re in the class, but not in a method, field or nested type.
• The Javadoc comment inserted is based on the Code Templates defined  under Window > Preferences > Java > Code Style > Code Templates. If you expand the Comments section, you can change the default for Fields, Methods, Types (eg. classes), etc.

Here’s a video to give you an idea of how fast and easy it is to add/remove comments using these shortcuts. The video shows toggling of single line comments, block comments and also adding a Javadoc comment to the method and class.

Once I’ve commented out lines, I often find myself copying them and moving them around (eg. to try different variations of the code). You can do this faster by moving and copying lines using with a single keystroke.

You can also have Eclipse format the comments whenever you save, saving you formatting time.

Related Tips

• Move, copy and delete lines with a single keystroke
• How to manage keyboard shortcuts in Eclipse and why you should
• Automatically format and cleanup code every time you save
• Configure those annoying tooltips in Eclipse to only popup on request
• More tips on faster and easier code editing and useful keyboard shortcuts.

Share This Tip

But there is a compiler setting in Eclipse that can warn you when you don’t use an argument in a method. You can even handle arguments on inherited methods, especially useful when using 3rd party libraries.

Setup the compiler preferences

To get warnings of unused arguments:

1. Go to Window > Preferences > Java > Compiler > Errors/Warnings.
2. Open up the section Unnecessary Code.
3. Change the setting for Parameter is never read from Ignore to Warning.
4. (Recommended, but optional) Deselect Ignore overriding and implementing methods. I recommend deselecting this option. You can leave it selected if you want to, but the feature loses a bit of its usefulness. I discuss this option a bit more in the next section.

Here’s what the preference should look like:

And here’s an example of such a warning. In the example, the argument capacity isn’t used so is annotated as a warning.

What’s the easiest way to get rid of the warning? Well, just remove the argument using the Eclipse Change Method Signature refactoring. This will remove the argument from the method declaration and any method callers in one go. However, if you can’t remove the argument from the method then read the next section.

On an old codebase you may get lots of warnings initially. I’d normally handle these on a class-by-class basis only for the classes I’m currently working on, unless the team has a specific cleanup project/task. Just something to bear in mind, especially if you share workspace settings across the team via SVN or similar.

What about method signatures that can’t be changed?

When you deselected Ignore overriding and implementing methods, you told Eclipse to warn you about unused arguments in implemented/overridden methods. It’s a good indicator that your superclass/interface method is passing in more than it needs to (ie. remove the argument from the method signature) or that you’re ignoring something important about the interface contract (ie. use it somewhere in your method).

But sometimes you can’t remove the argument because you don’t have control over inherited methods, especially if you implement/override a 3rd party library’s method or if the method is part of a bigger framework that’s difficult to change. Other times you won’t have any need for the argument in very isolated cases. So you don’t want a warning to appear for these.

That’s why you can use the @SuppressWarning compiler annotation to stop Eclipse from reporting the warning. Here’s an example:

public String process(@SuppressWarnings("unused") int capacity, int max) {...}

You can apply SuppressWarning to an individual argument or the whole method. I’d recommend annotating only the argument that you want to ignore.

Eclipse makes it easy to add the compiler annotation. Just navigate to the warning, press Ctrl+1 and choose Add @SuppressWarning ‘unused’ to ‘variable’ (Quick Fix does its job again).

Related Tips

• Navigate and fix errors and warnings in a class with Eclipse keyboard shortcuts
• Add, remove and reorder a method’s arguments instantly across multiple classes in Eclipse
• Find all classes that override/reimplement a method
• Automatically format and cleanup code every time you save
• More tips on faster refactoring and other useful preferences.

Share This Tip

For example, in the code below we want to refactor “shovel and spade” to a private static final String called TOOLS. To do that manually would take some time. It goes even slower if we only want to extract “spade” to a constant because we first have to convert the string to a concatenation.

String tools = "shovel and spade";
...
String otherTools = "shovel and spade";

Luckily, Eclipse has a couple of ways to instantly convert literals to constants. Coupled with tools to speed up string selection and to pick out part of a string, you have the ability to create a constant in about 2 seconds flat. I’ll discuss all these features below.

Extract a constant from a string/number

There are 2 ways to extract a constant, the one uses a quick fix and the other a refactoring. I’ll show the quick fix method first and then the refactoring and discuss the (small) differences between the two. The example uses a string, but everything is true for numbers as well.

Follow these steps to use the quick fix:

1. First select the string. The fastest way is to place the cursor on the string and press Alt+Shift+Up (Select Enclosing Element; a nifty shortcut that I discuss in Select strings and methods with a single keystroke).
2. After selecting the string, press Ctr+1 (Quick Fix) and then select Extract to constant. Eclipse will do the following: (a) Create a private final static variable of type String with a default name, (b) replace all occurrences of that string with the constant and (c) place the cursor on the constant’s declaration to give you a chance to change the name, type and visibility of the variable using placeholders that you can Tab through.
3. Once you’re happy with the constant details, press Enter to go back to the line on which you initiated the quick fix.

Here’s a short video with an example of using quick fix. We’ll extract a constant (called TOOLS) from a string literal (“shovel and spade”) that’s used in two places.

Note: You can use Tab to move from one placeholder to another and pressing Enter will get you back to your original line.

The other way to extract a constant is by using the Extract Constant refactoring. Again, select the string, then select Refactor > Extract Constant… (Alt+T, A) from the application menu. A dialog appears prompting you for the constant’s name, its visibility and whether to replace all occurrences of the string with the constant. After you’ve entered the details, press Enter and you’ll have your constant defined.

Here’s a short video with an example using refactoring. We’ll use the same example as above.

The differences between the two? Not much, the biggest difference being when you enter the details of the constant (ie. before the change is made or after). The refactoring dialog also provides an option to add the qualifying type name before the constant’s usage, but most of time this is redundant. I’d recommend using the quick fix, unless you’re more comfortable with dialogs.

BTW, you can assign custom keyboard shortcuts to either command by mapping either Quick Assist – Extract Constant or the command Extract Constant.

Pick out part of a string

Sometimes you’ll want to break up a string into multiple parts and convert one of those parts into a constant. Eclipse can do this automatically.

Select the part of the string you want to pick out (don’t worry about quotes), press Ctrl+1 and choose Pick out selected part of String. Eclipse will convert that part into a string with quotes, concatenate it to the rest of the string and select it. You can then use any of the Extract Constant tools above.

Here’s an example of how to use this feature. Notice how the string’s already selected so we can use the Extract Constant quick fix immediately.

Related Tips

• Select entire strings and methods in Eclipse with a single keystroke
• Convert string concatenations into StringBuilder or MessageFormat calls with Eclipse’s Quick Fix
• How to manage keyboard shortcuts in Eclipse and why you should
• Join/split if statements and rearrange expressions using Eclipse Quick Fix
• More tips on using quick fixes and making editing faster.

Share This Tip

The thing is that you’ll often only work with 1 or 2 at a time, not the whole lot. And sometimes you want a convenient way of only browsing projects belonging to a specific product/feature/layer/any-other-grouping-that-makes-sense. Having all projects in a long list makes it difficult to manage and more difficult to browse.

That’s why the Package Explorer and Project Explorer have a nice feature that reduces the clutter and allows you to organise your project into categories that make sense. So instead of the Package Explorer looking unwieldy and flat like this,

it could look like this:

How to categorise projects

This feature works closely with another Eclipse feature called Working Sets. A working set is just a grouping of resources (ie. files, folders and projects). Each category is just a working set.

To categorise projects, we’ll first create some working sets and then enable the feature in the Package Explorer.

To create a working set do the following:

1. Open the Package Explorer (or Project Explorer) and in the View Menu (triangle in the upper, right corner), click Select Working Set…
2. Click New… in the Select Working Set dialog.
3. Select Resource working set type and click Next.
4. On the next page select all the projects you want to include in the working set and pick a descriptive name for your working set. Repeat the process for any other working sets you want.
5. Click Finish.

Here’s an example of what the working set dialog should look like:

Now to enable the grouping feature. Open the Package Explorer’s View Menu again and enable Top Level Elements > Working Sets. If it’s the first time you do this, Eclipse will prompt you to configure working sets – a way to ask you which working sets to display in the Package Explorer. Select all the working sets you created and click Ok.

You should now see your working sets in the Package Explorer and if you expand it, all the projects you selected will be shown.

Here’s a quick video to give you an example of how this works and looks. In the example, there are 8 projects, 3 belonging to the UI and 3 to the model. The working sets will group them according to UI and Model. There are also 2 projects that are scratchpad projects, so for now they won’t be categorised.

Notes:

• A project can belong to as many working sets as you want, so it can appear in a number of categories.
• You can choose which working sets display in the Package Explorer by choosing Configure Working Sets… from the View Menu and then selecting/deselecting the relevant working sets. NB! This menu item is not available if you’re not in the Working Set layout.
• To get back to the normal view, select Top Level Elements > Projects from the View Menu.
• Any project not assigned to a working set goes to a category called Other Projects. This isn’t really a working set, but a default category that Eclipse assigns to group unassigned projects.
• You can reorder working sets by dragging and dropping them anywhere.
• New projects can quickly be assigned to working sets by either dragging and dropping them onto the working set or right-clicking on the project and selecting Assign Working Sets.

Limitations: Although working sets help you organise resources, any new resources won’t automatically be added to a working set, even if their parent already belongs to that working set. In our case, this means that any new project needs to be explicitly added to a working set, otherwise it will appear in the Other Projects category. Normally you can do this on New Project wizards, so watch out for these.

Some good reasons why you should categorise your projects

Now that you know how to group projects, you might be wondering why you should.

Well, apart from just looking a lot cleaner and less cluttered, it also means that you can act on a group of projects at a time. For example, you can right-click on a working set in Package Explorer and open, close or refresh all projects in that working set. The same applies to Team commands (nice for selective updates).

Another reason is that you can now selectively search only those projects by telling Eclipse to only search certain working sets. Now you don’t have to pick up occurrences in test or scratchpad projects if you don’t want to. There are a host of other Eclipse commands that act only on individual working sets (eg. build, problems, etc).

And the last reason is that now it’s a lot easier to navigate the Package Explorer with the keyboard. Another reason to start learning Eclipse keyboard shortcuts and also impress your colleagues.

Related Tips

• Instantly show a class/file in the Package/Project Explorer in Eclipse
• Use Fast Views to maximise screen space
• The fastest ways to navigate views in Eclipse using the keyboard
• Share Eclipse perspective layouts across multiple workspaces
• More tips on managing views, maximising screen space and navigating and browsing files.

Share This Tip

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
...
Map<String, String> map = new HashMap<String, String>();
List<String> list = new ArrayList<String>();
Set<String> set = new HashSet<String>();
String[] array = new String[] {};

To create any of these, you have to type a lot. Sometimes you make a mistake and have to retype. And half a minute later you’ve got one line of code that just declares a list. Also, you can have Eclipse automatically add imports when you save, but Eclipse normally can’t guess the correct List, instead prompting you to choose between java.util.List and java.awt.List (why isn’t there an option to use the former as the default?).

But Eclipse templates can help you avoid the hassle. Not only will it create the correct import statements, but also remove the effort of typing out the same type in the interface and implementation collection. If you’re new to templates, then see this tip to get an overview.

Import the templates automatically

Download the templates below then import them into Eclipse.

• Declaration templates: This bundle includes:
  arraylist: A List declaration together with an ArrayList initialisation. Automatically imports the correct list (java.util.List).
  hashmap: A Map declaration together with a HashMap initialisation.
  hashset: A Set declaration together with a HashSet initialisation.
• Initialisation templates: This bundle includes:
  initarray: An array declaration together with an array initialisation block.
  initlist: A List declaration together with an Arrays.asList() call for easy list initialisation.
  initmap: A Map declaration together with a call to Apache Commons Lang’s ArrayUtils.toMap() that makes light work of map initialisation. Commons Lang is sometimes already a dependency of external libraries so you may already be dependent on it, but this can extend to any other collection library (eg. Google Collections). You may get an unchecked warning because the method toMap() doesn’t use generics. I normally just add a @SuppressWarning(“unchecked).

Related Tips

Here are some more template-related tips to help you work faster:

• Check out the list of all templates that you can download and import into Eclipse.
• You can get an overview of templates to see what they are and how to use them.
• Once you have the template, you can see how to import or change it in Eclipse.

Share This Tip

So you might be wondering where the keyboard shortcuts for these actions are, because,  as I mentioned before, you normally work faster with keyboard shortcuts than jumping between the mouse and keyboard all the time. And often the longest part about working with repos is guiding your mouse through treacherous context menus and submenus.

The good news is that there are keyboard shortcuts in Eclipse for the most common repository commands (and not-so-common as well). The bad news is that most of them aren’t configured by default, so you need to set some of them up beforehand. But the 2 minutes spent configuring these may save you hours in the long run.

I’ll be using SVN as the example repository (using Subclipse) but these should apply to your favourite repository integrated into Eclipse (I know that the in-built CVS has these commands as well).

Common SVN keyboard shortcuts

So, here are the keyboard shortcuts you can configure and some suggestions for what to set them to. In summary, go to Window > Preferences > General > Keys, then use the Command colum below to search for the SVN command you’re interested in. But have a look at how to manage keyboard shortcuts for more details about configuring shortcuts. If you don’t like the suggested shortcut, you can, of course, choose any shortcut you like.

Note: None of these shortcuts are configured by default – you have to configure this yourself. Also, in the description, a resource can refer to a file, folder or project, including the active editor.

Also, Eclipse 3.6 (Helios) introduced a bug that disables the SVN keyboard commands by default. You have to enable these manually: Right-click on the toolbar and select Customize Perspective. Then go to Command Group Availability and in the Available command groups select the SVN option. This is probably still in 3.7 (see this Subclipse bug and this Eclipse bug for more details).

Be sure to configure the shortcut for the right repository. Eg, in the image below, there are two entries for commit, one for each of the repositories registered with Eclipse. Since I’m using Subclipse, I’m interested in the SVN category.

Depending on what you work with, you might want to consider other commands as well, such as Compare with Local Base Revision, Merge and Show Annotation.

Shortcuts for doing comparisons

Using shortcuts in the comparison editor can also make you work a lot faster. Note that you don’t have to configure the first two as they are configured by default.

These shortcuts replace the up/down arrows you’ll see in the comparison editor, eg. as in the image below. Pressing Ctrl+./Ctrl+, will move to the next change and select it so you can either edit it or copy the change from right to left.

Related Tips

These tips should help working with SVN and code in general a lot easier:

• Check out how to checkout multiple projects automaticallyfrom SVN using team project sets.
• Use many other keyboard shortcuts in Eclipse to work faster and let go of the mouse. Especially check out how to manage keyboard shortcuts and why you should.
• A lot of other tips can help with working with source control and also navigating Eclipse.

Share This Tip

But, for some reason, Eclipse doesn’t save perspective/window layouts, such as which views are open and where they are placed in the perspective. So you’ll find yourself spending another half hour configuring the window to the way you like it. After the 3rd workspace you need to create, this becomes frustrating and just wastes time.

Fortunately there are ways to save and restore these settings automatically. The first is to save the perspective into the preferences and the other is to use Eclipse’s Copy Settings feature when opening the other workspace. I prefer the first option, but I’ll mention the second option and when to use the one over the other.

Method 1: Save the layout as a new perspective

The first method is to save the perspective layout as another perspective, then export the preferences file as normal. The saved perspective’s settings will be included in the preferences file. When you’ve updated the layout,  just resave and overwrite the perspective and export the preferences again.

To save your perspective, select Window > Save Perspective As… from the application menu. A dialog should popup (shown below), prompting you for a perspective name. Enter a name  that you’ll remember, eg. My Java or Debug Jack. Click Ok once you’ve entered a new name.

Note: You can choose to overwrite one of the default perspectives, eg. Java, without fear. However, I prefer to leave these intact, so always choose a new name, but you can choose whatever works for you.

Now you can go through the normal routine of exporting the preferences to a properties file via File > Export > General > Preferences. Then import the same  file in another workspace via File > Import > General > Preferences. All you now have to do is switch over to the perspective you saved and all your layout settings will be restored. If you overwrote one of the default perspectives, you may have to select Window > Reset Perspective… to restore the saved settings.

If you’ve chosen to create a new perspective, be sure to point your Run/Debug settings to the new perspective under Window > Preferences > Run/Debug > Perspectives. For example, if you made a new perspective based on the Debug perspective, then you’ll need to change references to the Debug perspective to the My Debug for launchers you use. Luckily this is only required once as these settings are also saved when you export preferences (at least since Eclipse 3.5).

Gotcha: I use fast views a lot, and for some reason the Fast View dock’s position isn’t restored automatically. But manually restoring this is as easy as moving the dock, so it’s not that bad. Toolbar settings aren’t saved either, but I haven’t tampered with these a lot anyway since I prefer using the keyboard and mouse gestures.

Method 2: Use Copy Settings

The other method of saving your window layout is to use the Copy Settings feature when switching to another workspace.

To use this feature, first open the workspace that contains your customised layout. Then select File > Switch Workspace > Other… which will open a dialog prompting you for an existing/new workspace. Select the workspace, then click the Copy Settings collapsible section. Select the Workbench Layout checkbox and click Ok. Your workspace will open and should reflect the customised layout of the previous workspace.

Here’s what the dialog looks like:

Which method should I use?

Well, as I said before, I prefer the first method for a number of reasons. If some of these apply to you then you might want to use the first method as well. Use this method if:

• You want to share layout settings across workspaces on different machines, eg. work and home. This method is a lot more portable because you only need one single properties file.
• You spend 90% of your time in 1 or 2 perspectives (eg. Java & Debug) then this method works well because you only have to manage those perspectives.
• You make a lot temporary changes to perspectives that you don’t necessarily want shared. For example, if you’ve opened a number of views that you rarely use, you don’t want to clutter your new workspace with these views. I find that I have my “base” perspective layout, around which things will change depending on the context and I don’t want these to clutter my “base” layout.
• You want to share preferences with a colleague/friend.

Use the Copy Settings method if:

• You want to quickly create another workspace with the saved layout without having to export any preferences.
• You have made a number of changes across many perspectives and you want to restore those settings.
• You’re feeling lazy. With this method, Eclipse manages a lot more things, so it’s a bit easier to manage (in the short-term), but for the longer term, the first method is best.

Related Tips

So now you know how to save window layouts, have a look at these other tips:

• You can use fast views to maximise screen space. Very handy for small screens.
• And here are some fast ways to navigate between views using the keyboard.
• Sharing workspace settings is one thing, but you can also share plugins across multiple Eclipse installations.
• Here are some tips on how to set some useful preferences, so you can save and share them later.
• Check out other handy tips on how to manage views and the window in general.

Share This Tip

So there must be a better way to jump between the errors/warnings  than to use the mouse or page down to the next error. These methods are not only slow but often frustrating because you tend to miss the annotation, especially if it’s a big class. And navigating to the Problems view using the keyboard is ok, but sometimes overkill for just clearing out errors/warnings in one class.

A good thing then that Eclipse offers keyboard shortcuts that take you to the next/previous annotation in the class. And it does so in a way that selects the annotation immediately, allowing you to use Quick Fix (Ctrl+1) to fix it fast. So here’s how to use these shortcuts to navigate between the error/warning annotations and fix some of the errors easily.

How to jump between errors and warnings

Below are the keys you can use to go to the next/previous annotation and to initiate quick fix.

To see how fast the next annotation/quick fix combo works, I’ve set up an example in the following video that shows a class with multiple errors/warnings and how using the next/previous annotation and Quick Fix combo can make you work faster. There’s 1 warning (an unused variable, message, that should die) and 2 errors (not wrapping a FileOutputStream call in a try-catch and not initialising a local variable output).

Obviously not all errors are going to be solvable by Quick Fix, but some are: Adding a missing cast, filling in types for generics and adding the @SuppressWarning or @Override annotations.  And for the rest, at least you’ll be able to get to them easily. Bonus Tip: Also see how to cleanup some of these warnings automatically every time you save.

You can, of course, remap any of these keyboard shortcuts if they’re inconvenient. Have a look at how to manage your keyboard shortcuts, specifically looking out for the commands Next, Previous (yes, for some reason they’re just called Next and Previous) and Quick Fix.

Only jumping between errors

You might sometimes want to tell Eclipse to only move between errors (and not warnings) when you press the next/previous annotation command. Well, this is controlled by a Next/Previous Annotation dropdown menu in the toolbar (as shown in the image below). As you press the next/previous annotation key (either the keyboard shortcut or toolbar button), Eclipse will move to whatever annotations are checked in the dropdown.

Eclipse’s default only has Errors and Warnings selected (which is a reasonably good default, for once). You could disable Warnings if you only want to move between Errors, or vice versa.

Bonus Tip: The other selection you might want to enable is Occurrences. An occurrence is when you stand on a variable/method and Eclipse highlights it and its declaration and usages within the class. If you select Occurrences, pressing the next/previous annotation keys will also jump to the variable’s/method’s declaration and usages. This is nice when you want to quickly move to the variable’s usage in a long class. It’s optional if you want this on, so play around and see if it works for you.

Related Tips

Have a look at the following tips that may help you edit and fix code fast:

• You can navigate between views using the keyboard to quickly jump to the Problems view. This is another (slightly slower) way to fix errors using the keyboard.
• Knowing how to automatically format and cleanup code every time you save can eliminate some errors/warnings automatically, eg. adding imports, removing unused imports and private members, etc.
• Check out this raft of keyboard shortcuts that can make you work faster.
• Knowing how to use Quick Fix to make editing faster will make life a lot easier, so have a look.
• Also have a look at other tips that make editing faster and navigating Eclipse easier.
• Look at the Tips Archive for all the tips ever posted on Eclipse On E. There’s sure to be one that will help you work faster.

Share This Tip

public class Contact {
    private String name, surname;
    private int age;

    public Contact(String name, String surname, int age) {
        this.name = name;
        this.surname = surname;
        this.age = age;
    }
}

That’s 5 lines of code (lines 5-9) just to have a constructor. You could write them all by hand, but writing a constructor that accepts and initialises each field takes a lot of time and becomes irritating after a while. And creating constructors from a superclass can take even longer because the superclass can define multiple constructors that you need to reimplement.

That is why Eclipse has two features to help you generate these constructor instantly: Generate Constructor using Field and Generate Constructor from Superclass. Both features will generate a constructor in seconds, freeing you up to get to the exciting code. You’ll also see how to add/remove/reorder arguments of an existing constructor based on fields defined in the class.

Generate a constructor from fields

The fastest way to generate a constructor based on fields is to press Alt+Shift+S, O (alternatively select Source > Generate Constructor using Fields… from the application menu). This pops up a dialog where you can select the fields you want to include in the constructor arguments. Once you’ve selected the fields you want, just click Ok and you’re done. BTW, Alt+Shif+S is the shortcut to display a shortened Source menu, allowing Java source editing commands.

The following video shows an example of how much time this feature can save you. We’ll create a constructor for the class Message.

Notes:

• You can additionally call a superclass constructor with a subset of the fields by changing the dropdown Select super constructor to invoke at the top of the dialog. This creates a super(…) call with the relevant arguments and initialising code for the rest of the arguments on your subclass’s constructor.
• If you don’t want the JavaDoc for the constructor, disable the checkbox Generate constructor comments on the dialog.
• You can include/exclude the calls to super() using the checkbox Omit call to default constructor super(), on the dialog.
• You have to be positioned in a class to invoke this command.

If you use frequently use this command, you can remap its keyboard shortcut by changing the key binding for the command Generate Getters and Setters.

Generate constructor(s) from a superclass

Sometimes you’ll want to reimplement some/all of a superclass’s constructors, especially as part of the contract.

To generate constructor(s) from a superclass, just press Alt+Shift+S, C (or alternatively select Source > Generate Constructor from Superclass… from the application menu). A dialog pops up allowing you to select the constructor(s) you’d like to create. Once you click Ok, Eclipse generates the constructor, together with a super() call.

Here’s an example of how to create a constructor in SecretMessage, that inherits from the class Message. Message has three constructors: a default one, one that accepts one String (content) and another that accepts three Strings (content, fromAddress and toAddress). SecretMessage should only expose the last two constructors.

Note: You have to be positioned in a class to invoke this command.

If you use this command frequently, you can remap its keyboard shortcut by changing the key binding for the command Generate constructors from superclass.

Add, reorder and remove fields on existing constructors

If you have an existing constructor and want to reorder its arguments or remove some of them, have a look at the Change Method Signature refactoring that does that in a jiffy.

If you want to add a single field to an existing constructor, have a look at the next video that uses Eclipse’s Quick Fix (Ctrl+1) to do that easily. I’ll add a field createdDate to an existing constructor in Message by choosing Assign parameter to field from the Quick Fix menu while positioned on the field.

Related Tips

Now that creating constructors is as easy as making lunch, have a look at some other tips that help you generate boilerplate code faster.

• The Change Method Signature refactoring comes in handy when you want to reorder/remove arguments from a constructor.
• Have a look at other ways to make editing classes easier and faster.
• You can use templates to generate boilerplate code faster. Also see a list of some useful templates, such as those for log4j and JUnit.
• Eclipse’s Quick Fix can do a lot of other things for you. For example, have a look at how to join/split if statements faster or how to convert a string concatenation into a call to StringBuilder or MessageFormat using Quick Fix.

Share This Tip

import org.junit.After;
import org.junit.Before;
import org.junit.Test;

public class EngineTest {
    @Before
    public void setup() {
        ...
    }

    @Test
    public void test() throws Exception {
        ...
    }

    @After
    public void tearDown() {
        ...
    }
}

If you want to add a test, you have to somehow add lines 3, 11, 12 and 14 before you even get to the actual test. The same holds for setup and teardown code. We know that Eclipse can help with adding imports automatically when you save or autocomplete, but it still takes time to get everything in place.

Eclipse templates can help take away the drudgery by adding all this boilerplate code automatically. It can automatically add a test, setup and teardown methods together with calls to assertEquals, assertTrue and others. I’m assuming JUnit 4 in all the templates. If you’re new to templates, then see this tip to get an overview.

Import the templates automatically

Download the template below then import it into Eclipse.

• JUnit_templates: This bundle includes:
  test4: Creates a test method together with the @Test annotation and its import. NB: The 4 at the end is to distinguish it from two other  Eclipse built-in templates called test and Test.
  setup4: Creates a setup method with the @Before annotation and its import.
  teardown4: Creates a teardown method (called tearDown) with an @After annotation and its import.
  asequals: A call to assertEquals with its static import. The expected an actual default to locally available objects, but can easily be changed.
  astrue & asfalse: A call to assertTrue/assertFalse and its static import. The argument defaults to the nearest boolean but can easily be changed.
  asnull & asnotnull: A call to assertNull/assertNotNull and its static import. The argument defaults to the nearest object, but can easily be changed.

If you want to create the templates manually, open the template XML in your favourite XML editor, then see this tip, taking the values from the relevant fields in the XML.

Related Tips

Here are some more templated-related tips to help speed up coding:

• Automatically generate static imports when you use autocomplete on JUnit methods such as assertEquals.
• Have a look at how to run JUnit tests using only the keyboard.
• Here’s how to quickly navigate to and from the JUnit view using the keyboard.
• Check out the list of all templates that you can download and import into Eclipse.
• You can get an overview of templates to see what they are and how to use them.
• Once you have the template, you can see how to import or change it in Eclipse.

Share This Tip

It’s a good thing Eclipse can automatically put the semicolon at the end of the line, no matter where you are in the statement. It’s as easy as setting one preference and there’s a bonus preference for adding braces to the correct position as well. For something so small, it saves a lot of time.

So in the example below, if you imagine that your cursor is placed after the word blue since you were editing the string. Pressing semicolon will cause Eclipse to place the semicolon after the closing bracket at the end. Nice.

System.out.println("The house is blue")

How to set the semicolon preference

The preference is disabled by default, so you have to enable it. Go to Window > Preferences > Java > Typing. Then enable Semicolons under the section Automatically insert at correct position.

Now when you press semicolon from anywhere in a statement, Eclipse adds a semicolon to the end of the line and places the cursor right after the semicolon so you can start editing the next line.

The preference should look like this:

Notes:

• Sometimes you’d want to add a semicolon to a string literal instead of at the end of the line. Eclipse caters for this by allowing you to press Backspace after you pressed semicolon. Pressing Backspace will remove the semicolon from the end of the line, move your cursor to the original position in the string and add the semicolon to the string.
• If there’s already a semicolon at the end of the line, Eclipse won’t try to add another to the end. It will just add the semicolon to wherever you placed it.
• Eclipse is smart enough to know that for for loops you’d want to add the semicolon to the middle of the statement (eg. when editing the initialiser, condition and increment code).

Bonus Tip: You can also add braces automatically at the correct position by selecting the Braces option on the preference page. This comes in handy when your coding standards require braces to be on the same line as the control structure statement. For example, when adding a for or while loop, you can type { at any place in the first line and Eclipse will insert it at the end of the line.

Related Tips

• Automatically format and cleanup code every time you save
• Select entire strings and methods in Eclipse with a single keystroke
• Jump to the start and end of methods, loops, blocks and XML tags
• If you use templates, you won’t have to add semicolons to boilerplate code as they’ll be part of the template.

Share This Tip

Fortunately, Eclipse has a number of ways to navigate between views using only the keyboard. I’ll discuss the Show View shortcuts, the Show Views dialog, Quick Access and then view cycling, with some advice on when to use which one. There’s also a bonus tip on how to activate the editor with the keyboard once you’re done with a view.

Navigate between views using shortcuts

The fastest way to get around views, is to use the Show View keyboard shortcuts that take you directly to a view, no matter where you are in the window. The Show View commands are activated by pressing Alt+Shift+Q, then the letter for the relevant view, eg. to navigate to the Package Explorer, press Alt+Shift+Q, P.

The Show View command opens the view if it’s not opened in the current perspective, makes it visible then activates the view. So you can even open views that aren’t already open in the perspective.

Here’s a list of common views that you’ll probably use every day as a Java developer:

You may want to change the shortcut for a view that you use often to open it faster (eg. make Alt+Shift+P navigate to the Package Explorer). On the Keys preference dialog, search for Show View. Eclipse will list all views that are registered with the workbench. You can now reassign the key to your favourite view.

Some views don’t have shortcuts assigned to them, only waiting for you to do the honours. Again, you can use the Keys preference dialog to assign a shortcut to an unassigned view.

As always for the forgetful, to quickly get a list of all available Show View shortcuts, press Alt+Shift+Q, release it and wait for the list to appear in the lower right corner of the screen. It should look something like this:

Show views dialog

The next fastest way to navigate views is to press Alt+Shift+Q, Q. This pops up a dialog with a list of all views Eclipse knows about. The dialog is grouped by category and comes with a handy search box for you to easily find the view you want. The search box supports wildcards — a handy feature if you don’t know the exact name of the view you’re looking for. Once you’ve chosen the appropriate view, just press Enter.

Here’s an example of what the dialog looks like when you use the search feature:

You can also use the arrow keys to move to the view of your choice: Up/Down to move to the next folder grouping or view and Left/Right to open a folder. But I would recommend getting used to the search box as it’s faster to get to the view you want.

Tip: If the view you want is at the top of the list, you don’t have to press Down to select it. Pressing Enter will select the first view in the list and then pressing Enter again will confirm your selection.

Navigate views using Quick Access (Ctrl+3)

Quick Access is a way to navigate to anywhere or invoke anything in Eclipse. By pressing Ctrl+3, Eclipse pops up a searchable list of all perspectives, views, preferences, commands, etc. that it knows about. It sounds far-fetched, but try it out yourself to see what I mean.

You can navigate to a view by typing its name in the search bar. The search supports implicit wildcards, so you don’t have to type an asterisk to do a wildcard search. So to navigate to the Package Explorer, you can type Package in the search bar.

This is an example of what you’ll see when you use this dialog’s search feature:

Unfortunately you may get a lot of other entries that match the word Package since other things like commands and preferences may contain the same word. This gives the Show Views dialog a slight edge over Quick Access when it comes to navigating views since it only shows views.

Cycle views (Ctrl+F7)

This is probably the slowest and most frustrating way to navigate views. By pressing Ctrl+F7 (Next View), Eclipse pops up a list of all open views in the current perspective. To cycle through the list, hold down Ctrl and press F7 repeatedly.

Here’s what the list looks like:

There are 2 big problems with view cycling, though, which makes it one of my least favourite commands:

1. If the view you want is at the bottom of the list, it takes a while to reach it. And if you accidentally move past it, you need to wrap around and try and hit it again, or you have to swap over to Ctrl+Shift+F7 to move backwards in the list. Definitely not nice.
2. The list only shows open views in the current perspective. Not usable if you want to open an infrequently used view.

However, this shortcut does come in handy when you’re constantly swapping between two views (eg. doing a side-by-side comparison). By pressing Ctrl+F7 once, Eclipse switches between the currently active and last active view.

Activate the editor using the keyboard

You may want to know how to use your keyboard to give the editor focus once you’re done with a view, especially helpful if you’re avoiding the mouse.

To activate the editor from any view, press F12. This means that you don’t have to reach for the mouse to start editing. This command is called Activate Editor and can be changed to any shortcut you want. F12 is not the most convenient key on most keyboards, so you may want to change it if it doesn’t suit you.

So, when should you use one or the other?

I would recommend the following to start off with:

• For frequently used views, learn the Show View keyboard shortcut (eg. Alt+Shift+Q, P) for the Package Explorer. It’s the fastest and most direct way to get to a view.
• For infrequently used views, learn to use the Show Views dialog, or alternatively Quick Access. The Show Views dialog is better because it only contains a list of views, so it makes things a bit simpler than the Quick Access dialog.
• Use Next View (Ctrl+F7) only when you’re constantly swapping between two views. Avoid it for other scenarios.

Related Tips

So now that navigating views is a bit easier, here are some other tips that may come in handy:

• Quick ways to navigate Eclipse editors using the keyboard
• The fastest ways to open editors in Eclipse using the keyboard
• Categorise projects in the Package Explorer to reduce clutter in Eclipse
• Use Fast Views to maximise screen space
• Split and view the same editor side by side in Eclipse
• Switch and close editors faster with the keyboard using Eclipse’s Quick Switch Editor
• How to manage keyboard shortcuts in Eclipse and why you should

Share This Tip

For some it may not happen that often, but the job becomes difficult when you have a dozen or more classes that call that method. All of them need to be changed to match the new signature and this can take a long time to change.

Fortunately, Eclipse has a refactoring called Change Method Signature that makes this easy, allowing a signature change in almost no time across any number of classes. This can be a huge timesaver when you need it and save you hours of frustration trying to fix red crosses in Eclipse.

How to change a method signature

The refactoring is easy to invoke. The fastest way to do this is to position the cursor on the method’s declaration or any of it’s calls and then press Alt+Shift+C (or alternatively select Refactor > Change Method Signature from the application menu). This can only be invoked on methods for which you own the code.

In the next video I show an example of adding a new String argument called message to the method process as the second argument. Notice how Eclipse automatically shifts all other arguments up by one. Then we’ll remove the int argument. The two affected classes are below each other so you can see the magic in action.

Notes:

• To reorder the arguments, just press the Up/Down buttons.
• You can specify a default value for the new argument. This is the default value that Eclipse will give all method calls. Normally null or another sensible default will do.
• You can preview the changes before you accept them. Eclipse shows you all affected classes and allows you to compare the current and soon-to-be code.
• Eclipse has Content Assist inside the refactoring dialog, meaning that you can press Ctrl+Space in the Type column to see a list of object types that match the name you’ve typed.
• You can change the return type and even the name of the method. If you just want to rename a method, rather use the Rename refactoring (Alt+Shift+R).

Related Tips

Here are some other tips that might interest you:

• The example video shows two editors below each other. You can find out how to see the same editor side by side in Eclipse.
• While you’re refactoring code, check out some other refactorings that Eclipse provides that could help you. You can also have a look at other editing tips that may interest you.
• You can remap the keyboard shortcut if you find Alt+Shift+C doesn’t work for you (the command’s name is Change Method Signature). There are also other keyboard shortcuts you can check out as well to make coding a lot faster, meaning you don’t have to reach for that mouse to refactor you code.