Editing | Refactoring | Navigation | Searching | Views | Miscellaneous | Debugging |
Content assist | Content assist provides you
with a list of suggested completions for partially entered strings.
In the Java editor press Ctrl+Space or invoke Edit >
Content Assist.
|
Content assist in Javadoc comments | Content assist is also
available in Javadoc comments.
|
Suppress types in content assist |
To exclude certain types from appearing in content assist, use the type
filter feature configured on the
![]() |
Content assist for variable, method parameter and field name completions |
You can use content assist to speed up the creation of fields, method
parameters and local variables. With the cursor positioned after the
type name of the declaration, invoke Edit > Content Assist
or press Ctrl+Space.
If you use a name prefix or suffix for fields, local variables or
method parameters, be sure to specify this in the
|
Parameter hints | With the cursor in a method
argument, you can see a list of parameter hints. In the Java Editor
press Ctrl+Shift+Space or invoke Edit > Parameter Hints.
|
Content assist on anonymous classes | Content assist also
provides help when creating an anonymous class. With the cursor
positioned after the opening bracket of a class instance creation,
invoke Edit > Content Assist or press Ctrl+Space.
|
Toggle between inserting and replacing content assist | When content assist is invoked
on an existing identifier, it can either replace the
identifier with the chosen completion or do an insert. The
default behavior (overwrite or insert) is defined in the
![]() You can temporarily toggle the behavior while inside the content assist selection dialog by pressing and holding the Ctrl key while selecting the completion. |
Incremental content assist | Per default, content assist will now Insert common prefixes automatically, similar to
Unix shell expansion. To change that behavior uncheck the setting on the
![]() |
Customize content assist
![]() |
Repeatedly invoking content assist (Ctrl+Space) cycles through different proposal
categories.
![]() You can also assign separate key shortcuts to your favorite proposal categories. |
Create getters and setters | To create getter and setter
methods for a field, select the field's declaration and invoke Source
> Generate Getter and Setter.
![]() |
Use content assist to create getter and setters | Another way to create
getters and setters is using content assist. Set the cursor in the
type body between members and press Ctrl+Space to get the proposals
that create a getter or setter method stub. ![]() |
Delete getters and setters together with a field | When you delete a field
from within a view,
Eclipse can propose deleting its Getter and Setter methods.
If you use a name prefix or suffix for fields, be sure to specify this in the
![]() |
Create delegate methods | To create a delegate method
for a field select the field's declaration and invoke Source >
Generate Delegate Methods. This adds the selected methods
to the type that contains a forward call to delegated methods. This
is an example of a delegate method: ![]() |
Create hashCode() and equals()
![]() |
To create the methods hashCode() and equals()
invoke Source > Generate hashCode() and equals().
|
Use Templates to create a method | You can define a new
template that contains a method stub using the
![]() There are also existing templates, such as 'private_method', 'public_method', 'protected_method' and more. Use the Tab key to navigate between the values to enter (return type, name and arguments).
|
Use Quick Fix to create a new method | Start with the method
invocation and use Quick Fix (Ctrl+1) to create the method.
|
Use Quick Fix to change a method signature | Add an argument to a method
invocation at a call site. Then use Quick Fix (Ctrl+1) to add the
required parameter in the method declaration.
|
Use Content Assist to create a constructor stub | At the location where you
want to add the new constructor, use content assist after typing the
first letters of the constructor name.![]() |
Create new fields from parameters | Do you need to create new
fields to store the arguments passed in the constructor? Use Quick
Assist (Ctrl+1) on a parameter to create the assignment and the
field declaration and let Eclipse propose a name according to your Code
Style preferences.![]() |
Use Content Assist to override a method | Invoke Content Assist
(Ctrl+Space) in the type body at the location where the method
should be added. Content assist will offer all methods that can be
overridden. A method body for the chosen method will be created.
|
Use Quick Fix to add unimplemented methods | To implement a new
interface, add the 'implements' declaration first to the type.
Even without saving or building, the Java editor will underline the
type to signal that methods are missing and will show the Quick Fix
light bulb. Click on the light bulb or press Ctrl+1 (Edit >
Quick Fix) to choose between adding the unimplemented methods or
making your class abstract.
|
Override a method from a base class | To create a method that
overrides a method from a base class: Select the type where the methods should be added and invoke Source > Override/Implement Methods. This opens a dialog that lets you choose which methods to override.
|
Create a type from an example snippet ![]() |
You can paste a snippet of code containing a Java type directly
into a package or source folder to create a new compilation unit.
For example select and copy this source code
package pack; public class HelloWorld { public static void main(String[] args) { System.out.println("Hello World"); } }then select a source folder in the Package Explorer use Ctrl+V (Edit > Paste). This automatically creates a new package 'pack' and file 'HelloWorld.java' with the copied content. |
Rename in file | To quickly do a rename that
doesn't require full analysis of dependencies in other files, use the
'Rename in file' Quick Assist. In the Java Editor, position the
cursor in an identifier of a variable, method or type and press Ctrl+1
(Edit > Quick Fix) The editor is switched to the linked edit mode (like templates) and changing the identifier simultaneously changes all other references to that variable, method or type.
![]() |
Use Quick Fix to handle exceptions | Dealing with thrown exceptions is
easy. Unhandled exceptions are detected while typing and marked with
a red line in the editor.
|
Less typing for assignments | Instead of typing an assignment, start
with the expression that will be assigned.
![]() |
Less work with cast expressions | Don't spend too much time with typing casts. Ignore them first and use quick assist to add them after
finishing the statement.
For example on assignments: |
Assign a casted
expression |
After an 'instanceof' check, it is very common to cast the expression and assign it to a new local variable. Invoke Quick
Assist (Ctrl+1) on the 'instanceof' keyword to save yourself some typing:![]() |
More quick assists |
Check out the quick assist page for a complete list of available code transformations. Amongst them are
|
Shortcuts for Quick Fixes and Assists |
Some of the popular quick assists like Rename
In File and Assign To Local can be invoked
directly with Ctrl+2 R and Ctrl+2 L. Check
the
![]() |
Surround lines | To surround statements with an if /
while / for statement or a block, select the lines to surround and
invoke Source > Surround With or press Alt+Shift+Z.
The entries in the menu are derived from the normal editor templates: All templates that contain the variable ${line_selection} will show up in the menu. Templates can be configured on the![]() |
Create your own templates |
To create your own templates, go to the
![]()
|
Content assist can insert argument names automatically |
You can have content assist insert argument names automatically on
method completion. This behavior can be customized on the
![]()
content assist will automatically insert argument names:
You can then use the Tab key to navigate between the inserted names. Content assist can also guess argument names - based on their
declared types. This can be configured by the Guess filled
argument names checkbox on the
|
Automatically insert
type arguments |
Enabling Fill argument names on completion on the
![]() ![]() results in: ![]() |
Remove surrounding statement | To remove a surrounding statement or
block, position the cursor at the opening or closing bracket and press Ctrl+1
(Edit > Quick Fix).
|
How was that word spelled again? | You can enable spell-checking support in the Java editor on the
![]() You can make the dictionary also available to the content assist. However, there is currently no dictionary included in Eclipse. The required format is just a list of words separated by new lines and the Quick Fixes allow you to add new words to the dictionary on-the-fly. Contributions of dictionaries would be welcome. |
Structured selections | You can quickly select Java code
syntactically using the Structured Selection feature. Highlight the text and press Alt+Shift+Arrow Up or select Edit > Expand Selection To > Enclosing Element from the menu bar - the selection will be expanded to the smallest Java-syntax element that contains the selection. You can then further expand the selection by invoking the action again. |
Find the matching bracket | To find a matching bracket select an
opening or closing bracket and press Ctrl+Shift+P or select Navigate >
Go To > Matching Bracket. You can also double click
before an opening or after a closing bracket - this selects the text
between the two brackets.
|
Smart Javadoc | Type '/**' and press Enter. This
automatically adds a Javadoc comment stub containing the standard
@param, @return and @exception tags.
![]() |
Show Source of Selected Element Only | Press the Show Source of Selected Element Only
![]() |
Use the local history to revert back to a previous edition of a method | Whenever you edit a file,
its previous contents are kept in the local history. Java tooling
makes the local history available for Java elements, so you can
revert back to a previous edition of a single method instead of the
full file.
Select an element (e.g. in the Outline view) and use Replace With > Local History to revert back to a previous edition of the element.
|
Use the local history to restore removed methods | Whenever you edit a file,
its previous contents are kept in the local history. Java tooling
makes the local history available for Java elements, so you can
restore deleted methods selectively.
Select a container (e.g. in the Outline view) and use Restore from Local History to restore any removed members.
|
Customizable code generation | The
![]()
|
Create comments in your code | Comments can be added explicitly with Source > Generate Element Comment (Alt+Shift+J) or automatically by various wizards, refactorings or quick fixes. Configure the comment templates on the ![]() Enable or disable the automatic generation of comments either directly on the wizard (e.g. using 'Generate Comment' checkbox on the new Java type wizards) or by the 'Automatically add new comments for new methods and types' checkbox of the ![]() All these settings can also be configured on a per project basis. Open the Properties on project to enable project specific settings. |
Sort members | You can Sort Members
of a Java compilation unit according to a category order defined in the
![]() You'll find the action under Source > Sort Members. |
Wrap strings |
You can have String literals wrapped when you edit them. For
example, if you have code like this:
String message= "This is a very long message."; position your caret after the word "very" and press Enter. The code will be automatically changed to: String message= "This is a very" + " long message."; This behavior can be customized in the
|
Smart Typing and how to control it |
The Java editor's Smart Typing features ease your daily work. You can configure
them on the
![]()
When you enable Automatically insert Semicolons at correct
position, typing a semicolon automatically positions the cursor at the end of the statement before inserting the semicolon. This safes you some additional cursor navigation. |
Fix your code indentation with one key stroke | A useful feature is Source
> Correct Indentation or Ctrl+I. Select the code where the indents are incorrect and invoke the action. If nothing is selected, the action indents the current line. |
Quick menus for source and refactoring actions |
The refactoring and source actions can be accessed via a quick
menu. Select the element to be manipulated in the Java editor or in a
Java view and press Alt+Shift+S for the quick source menu,
Alt+Shift+T for the quick refactoring menu and Alt+Shift+Z for the surround with menu.
|
Find unused code | The Java compiler detects
unreachable code, unused variables, parameters, imports and unused
private types, methods and fields.
The setting is on the
![]()
|
Javadoc comment handling | The Eclipse Java compiler can process Javadoc comments. Search
reports references in doc comments, and refactoring updates these
references as well. This feature is controlled from the
![]()
|
Suppress warnings | In J2SE 5.0 and later, you can suppress all optional compiler warnings using the SuppressWarnings annotation.In this example, addAll() is marked as an unused method. Quick Fix (Ctrl+1) is used to add a SuppressWarnings annotation so that the warning will not be shown for this method.![]() |
Clean Up Wizard ![]() |
The Clean Up Wizard helps fixing multiple
problems at once and helps to establish a code style. For instance, you can:
![]() Select a project, package, or file and use Source > Clean Up... to start this wizard. |
Scripting of refactorings![]() |
Most of the refactorings offered by JDT can not only be executed interactively, but also by a refactoring script. Create a refactoring script from the refactoring history using Refactor > Create Script.... A refactoring script can then be applied later on an arbitrary workspace using Refactor > Apply Script.... Such refactoring scripts can be used in different scenarios such as automatic fixing of breaking API changes between software layers or providing patches with rich semantics. |
Safe JAR file migration![]() |
When exporting a JAR file from the workspace, the JAR Export Wizard offers the option
to include refactoring information into the JAR file. Use File > Export... and select JAR file. On the first page of the JAR Export Wizard, select Export refactorings for checked projects. Click on the link to select the refactorings to include. Clients are then able to migrate an old version of the JAR file to a new one using the Refactor > Migrate JAR File... refactoring. This refactoring automatically updates all code which is dependent on the old version of the JAR file to use the new version of the JAR file. |
Locate variables and their read/write access | You can locate variables
and see their read/write status by selecting an identifier
(variable, method or type reference or declaration) and invoking Search
> Occurrences in File. This marks all references of this
identifier in the same file. The results are also shown in the search
view, along with icons showing the variable's read or write access.
Alternatively, use the Mark Occurrences feature to dynamically highlight occurrences. You can search over several files by using the general search features (Search > References). |
Search for methods with a specific return type |
To search for methods with a specific return type, use "*
<return type>" as follows:
|
Filter search matches in Javadoc | By default, Java Search finds references inside Java code and Javadoc. If you don't want to see the references inside Javadoc, you can filter these matches by enabling 'Filter Javadoc' in the view menu (triangle symbol) of the search view. |
Filter potential search matches | Potential matches occur when a compile-time problem prevents the search engine from completely resolving the match. Filter these matches with Filter Potential in the search view menu (triangle symbol). |
Trace method call chains with the Call Hierarchy |
Use the Call Hierarchy to follow long or complex
call chains without losing the original context: Just select a method
and invoke Navigate > Open Call Hierarchy (Ctrl+Alt+H).
|
Open on a selection in the Java editor | There are two ways that you
can open an element from a reference in the Java editor.
![]() The hyperlink style navigation can be configured with the Support hyperlink style navigation checkbox in the ![]() |
In-place outlines | Press Ctrl+F3 in the
Java editor to pop up an in-place outline of the element at the
current cursor position. Or press Ctrl+O (Navigate > Quick
Outline) to pop up an in-place outline of the current source
file.
|
In-place outlines show inherited members | Press Ctrl+O or Ctrl+F3
again to add inherited members to an open In-place outline. Inherited members have a gray label.
Filter and sort the outline with the menu in the upper right corner.
|
In-place hierarchy | Find out which are the
possible receivers of a virtual call using the Quick Type Hierarchy.
Place the cursor inside the method call and press
Ctrl+T (Navigate > Quick Type Hierarchy).
The view shows all types that implement the method with a full icon.
Press Enter to open the corresponding method in an editor. Press Ctrl+T again to switch to the Supertype hierarchy. |
Advanced highlighting |
The Java editor can highlight source code according to its
semantics (for example: static fields, local variables, static method
invocations). Have a look at the various options on the
![]()
|
Initially folded regions | You can specify which regions are folded by default when an editor is opened. Have a look at the
![]()
|
Mark occurrences |
When working in the
editor, turn on Mark Occurrences in the toolbar (![]() ![]() Selecting a return type shows you the method's exit points. Select an exception to see where it is thrown. ![]() Select a super class or interface to see the methods override or implement a method from the selected super type. Fine tune 'mark occurrences' on the ![]() Change the color for to marker on the ![]() |
Go to next / previous method | To quickly navigate to the
next or previous method or field, use Ctrl+Shift+Arrow Up (Navigate > Go To > Previous Member) or Ctrl+Shift+Arrow Down (Navigate > Go To > Next Member) |
Control your navigation between annotations |
Use the Next / Previous Annotation toolbar buttons or Navigate
> Next Annotation (Ctrl+.) and Navigate > Previous
Annotation (Ctrl+,) to navigate between annotations
in a Java source file.
With the button drop-down menus, you can configure on which annotations you want to stop:
|
Reminders in your Java code | When you tag a comment in
Java source code with "TODO" the Java compiler automatically creates
a corresponding task as a reminder. Opening the task navigates you
back to the "TODO" in the code. Use the
![]()
|
Tricks in the Open Type dialog |
The Open Type dialog (Navigate > Open Type or toolbar button) helps you navigate to a type
by its name.
![]() |
Make hovers sticky | You can open the text from
a hover in a scrollable window by pressing F2 (Edit > Show
Tooltip Description). You can select and copy content from this
window.
|
Hovers in the Java editor | You can see different hovers in the
Java editor by using the
modifier keys (Shift, Ctrl, Alt). When you move the mouse over an identifier in the Java editor, by default a hover with the Javadoc extracted from the corresponding source of this element is shown. Holding down the Ctrl key shows you the source code.
![]() |
Generic method inferred signature |
You can use hover to show the inferred signature of a generic method.
|
Open and configure external Javadoc documentation | If you want to open the
Javadoc documentation for a type, method or field with Shift+F2
(Navigate > Open External Javadoc), you first have to specify
the documentation locations to the elements parent library (JAR,
class folder) or project (source folder). For libraries, open the build path page (Project > Properties > Java Build Path), go to the Libraries, and expand the node of the library where you can edit the 'Javadoc location' node. The documentation can be local on your file system in a folder or archive, or on a web server.
|
Organizing workspace with many projects | Use Top Level Elements > Working Sets in the Package Explorer's view menu to enable
a new mode that shows working sets as top level elements. This mode makes it
much easier to manage workspaces containing lots of projects.
Use Configure Working Sets from the Package Explorer's view menu to configure which working sets get shown. The dialog lets you create new Java working sets, define which working sets are shown and in what order. Working sets can also be rearranged directly in the Package Explorer using drag and drop and copy/paste. |
||
Declaration view | The Declaration view
(
![]()
|
||
Javadoc view | There is a Javadoc view (
![]()
|
||
Type hierarchy view and method implementations / definitions | To find out
which types in a hierarchy override a method, use the 'Show Members in
Hierarchy' feature.
|
||
Type hierarchy view supports grouping by defining type | The type hierarchy method
view lets you sort the selected type's methods by its defining types.
For example, for AbstractList you can see that it contains methods
that were defined in Object, Collection and List:
|
||
Tricks in the type hierarchy |
|
||
Structural compare of Java source | A structural comparison of Java source
ignores the textual order of Java elements like methods and fields
and shows more clearly which elements were changed, added, or removed. For initiating a structural comparison of Java files you have two options:
|
||
Structural compare of property files | A structural comparison of Java
property files (extension: .properties) ignores the textual order of
properties and shows which properties were changed, added, or
removed. For initiating a structural comparison of property files you have two options:
|
||
Hierarchical vs. flat presentation of packages | An option on the Java
Packages (and Package Explorer) view menu allows you to change the
way packages are displayed. Package Presentation > Hierarchical displays packages in
a tree, with sub-packages below packages; Package Presentation > Flat displays them
in the standard arrangement, as a flat list with all packages and
sub-packages as siblings.
|
||
Logical packages | The Java Packages view
(Java Browsing perspective) coalesces packages of the same name
across source folders within a project. The screenshot shows the Packages view
containing a logical package.
|
||
Compress package names | If your package names are
very long, you can configure a compressed name that appears in the viewers.
Configuration of the compression pattern is done in the
![]()
|
||
Manipulating the Java build path directly in the Package Explorer | Instead of manipulating the Java Build path on Project
> Properties > Java Build Path, use the actions in the Package Explorer's context menu.
You can for example add new source folders, archives and libraries to the build path or in- and exclude file and folders from a source folder. |
||
Grouping Java problems![]() |
Configure the Problems view to group Java problems into categories with Group by > Java Problem Type
in the view menu.
![]() |
||
Java type indicator ![]() |
Enable the Java Type Indicator on the
![]() |
Project specific preferences | All code style and compiler options can be defined per project. Open the project property pages with Project > Properties on a project or use the link on the workspace preferences (e.g. the ![]() |
||||||||||||
Access rules |
Access rules give you the possibility to enforce API rules for types from referenced libraries. On the Java build path page (Project
> Properties > Java Build Path) edit the 'Access Rules' node available on referenced projects, archives, class folders and libraries. Packages or types in these references can be classified as:
![]() |
||||||||||||
JUnit | Select a JUnit test method in a view and choose Run > JUnit Test from the context menu or Run > Run As > JUnit Test from the main menu. This creates a launch configuration to run the selected test. | ||||||||||||
Hide JUnit view until errors or failures occur | You can configure the JUnit view
to only open when there are errors or failures. That way, you can have
the view set as a fast view and never look at it when there are no
failing tests. While there are no problems in your tests you will see
this icon ![]() ![]() ![]() ![]() |
||||||||||||
Content assist in dialog fields | Content Assist (Ctrl+Space) is also available in input fields
of various Java dialogs. Look for a small light bulb icon beside the
field when it has focus.
|
||||||||||||
Smart caret positioning in dialogs showing Java names
![]() |
Text fields for editing Java names support smart caret positioning. Use Ctrl+Left and Ctrl+Right to
stop at camel case boundaries inside a name. Use Ctrl+Shift+Left and Ctrl+Shift+Right to extend the selection in small steps.
Use Ctrl+Delete to delete the next and Ctrl+Backspace to delete the previous part of a name.
|
||||||||||||
Define prefixes or suffixes for fields, parameters and local variables | You can configure
the prefix or suffix for fields, static fields, parameters, and local variables.
These settings on the
![]()
|
||||||||||||
Organize Imports works on more than single files | You can invoke Source > Organize Imports on sets of compilation units, packages, source folders or Java projects. | ||||||||||||
Format more than one file | Select all Java files to format and choose Source > Format to format them all. The format action is also available on packages, source folders or Java projects. | ||||||||||||
Use a specific JRE for a project | When creating new projects, the JRE that
is added by default is the one selected in the
![]()
|
||||||||||||
Use drag and drop |
Drag and Drop is a handy replacement of Edit > Cut and Edit > Paste
respective Edit > Copy and Edit > Paste. Hold
down the Ctrl key down while dragging to change from move to copy.
Important to know:
|
||||||||||||
Propagating deprecation tag |
The Java compiler can be configured to diagnose deprecation using
options on the
![]()
|
||||||||||||
Recovering from abnormal inconsistencies |
In the rare event of a dysfunction, JDT could reveal some inconsistencies
such as:
To bring JDT into a consistent state again, the following actions need to be performed in this exact order:
|
Launching from the Context Menu |
You can run and debug Java applications from the context menu. You can launch a source file, package, method, type, etc. by choosing Run As (or Debug As) > Java Application from the context menu in a view or editor. Alternatively, you can use the Java application launch shortcut key binding (Alt+Shift+D, J). The top level Run As (or Debug As) actions are also sensitive to the current selection or active editor.
|
Evaluations in the debugger |
Snippet evaluation is available from a number of places in the debugger. Choosing Display or Inspect from the context menu of the editor or Variables view will show the result in a pop-up whose result can be sent to the Display or Expressions views.
|
View Management in Non-Debug perspectives |
The Debug view automatically manages debug related views based on the view selection (displaying Java views for Java stack frames and C views for C stack frames, for example). By default, this automatic view management only occurs in the Debug perspective, but you can enable it for other perspectives via the View Management preference page available from the Debug view toolbar pull down. |
Environment Variables |
You can specify the environment used to launch Java applications via the Environment tab.
|
String Substitutions |
Variables are supported for many parameters of Java Application launch configurations. Most fields that support variables have a Variables... button next to them, such as the program and VM arguments fields. The Main Type field supports variables as well; the ${java_type_name} variable allows you to create a configuration that will run the selected type.
|
Logical Structures |
The Logical Structures toggle on the Variables view toolbar presents alternate structures for common types. JDT provides logical views for Maps, Collections, and SWT Composites. You can define logical structures for other types from the Logical Structures preference page.
|
Default VM Arguments |
If you specify the same arguments to a certain VM frequently, you can configure Default VM Arguments in the Installed JREs preference page. This is more convenient than specifying them for each launch configuration.
|
Stop in Main |
You can use Stop in main in a Java Application launch configuration to cause your program to stop at the first executable line of the main method when you run it under debug mode.
|
Conditional breakpoints | You can use conditional breakpoints in
Breakpoint Properties... to control when a breakpoint
actually halts execution. You can specify whether you want the
breakpoint to suspend execution only when the condition is true, or
when the condition value changes.
|
Disabling breakpoints |
If you find yourself frequently adding and removing a breakpoint in the same place, consider disabling the breakpoint when you don't need it and enabling it when needed again. This can be done using Disable Breakpoint in the breakpoint context menu or by unchecking the breakpoint in the Breakpoints view. You can also temporarily disable all breakpoints using the Skip All Breakpoints action in the Breakpoints view toolbar. This will tell the debugger to skip all breakpoints while maintaining their current enabled state.
|
Changing variable values |
When a thread is suspended in the debugger, you can change the values of Java primitives and Strings in the Variables view. From the variable's context menu, choose Change Variable Value. You can also change the value by typing a new value into the Details pane and using the Assign Value action in the context menu (CTRL+S key binding).
|
Variable values in hover help | When a thread is suspended and the
cursor is placed over a variable in the Java editor, the value of
that variable is displayed as hover help.
|
Drop to Frame |
When stepping through your code, you might occasionally step too far, or step over a line you meant to step into. Rather than restarting your debug session, you can use the Drop to Frame action to quickly go back to the beginning of a method. Select the stack frame corresponding to the Java method you wish to restart, and select Drop to Frame from Debug view toolbar or the stack frame's context menu. The current instruction pointer will be reset to the first executable statement in the method. This works for non-top stack frames as well. Note that Drop to frame is only available when debugging with a 1.4 or higher VM, or the J9 VM. There are some situations where a JVM may be unable to pop the desired frames from the stack. For example, it is generally impossible to drop to the bottom frame of the stack or to any frame below a native method. |
Hot code replace | The debugger supports Hot Code Replace when debugging with a 1.4 or higher VM, or the J9 VM. This lets you make changes to code you are currently debugging. Note that some changes such as new or deleted methods, class variables or inner classes cannot be hot swapped, depending on the support provided by a particular VM. |
Stepping into selections |
The Java debugger allows you to step into a single method within a series of chained or nested method calls. Simply highlight the method you wish to step into and select Step into Selection from the Java editor context menu. This feature works in places other than the currently executing line. Try debugging to a breakpoint and step into a method a few lines below the current instruction pointer. |
Console pin and lock | Output displayed in the console can be locked to a specific process via the Pin Console action in the Console view toolbar. There's also a Scroll Lock action that stops the console from scrolling as new output is appended. |
Creating watch items | A watch item is an expression in the Expressions view whose value is updated as you debug. You can create watch items from the Java editor by selecting an expression or variable and choosing Watch from its context menu or the top-level Run menu. |
Watch points |
A watch point is a breakpoint that suspends execution whenever a specified field is accessed or modified. To set a watchpoint, select a field in the Outline view and choose Toggle Watchpoint from its context menu. To configure a watchpoint, select the watchpoint in the Breakpoints view and choose Properties... from its context menu. The most important properties for this type of breakpoint are the Access and Modification checkboxes which control when the breakpoint can suspend execution.
|
Threads and Monitors |
The Java debugger optionally displays monitor information in the Debug view. Use the Show Monitors action in the Debug view drop down menu to show which threads are holding locks and which are waiting to acquire locks. Threads involved in a deadlock are rendered in red. |
Step filters | Step filters prevent the debugger from suspending
in specified classes and packages when stepping into code. Step filters
are established with the
![]() |
Using the scrapbook |
If you want to experiment with API or test out a new algorithm, it's
frequently easier to use a Java scrapbook page than create a new class.
A scrapbook page is a container for random snippets of code that you can
execute at any time without a context. To create a scrapbook page, create
a new file with a .jpage extension (or use the
These actions are in the workbench toolbar and also in the scrapbook page's context menu. |
Editing launch configurations |
Holding down the Ctrl key and making a selection from the Run or Debug drop-down menu opens the associated launch configuration for editing. The launch configuration can also be opened from the context menu associated with any item in the Debug view. |
Favorite launch configurations |
Launch configurations appear in the Run/Debug drop-down menus in most recently launched order. However it is possible to force a launch configuration to always appear at the top of the drop-downs by making the configuration a 'favorite'. Use the Organize Favorites... action from the appropriate drop down menu to configure your favorite launch configurations. |
Detail formatters |
In the Variables & Expressions views, the detail
pane shows an expanded representation of the currently selected
variable. By default, this expanded representation is the result of
calling
|
Running code with compile errors |
You can run and debug code that did not compile cleanly. The only difference between running code with and without compile errors is that if a line of code with a compile error is executed, one of two things will happen:
It is important to emphasize that as long as your execution path avoids lines of code with compile errors, you can run and debug just as you normally do. |
Word wrap in Variables view | The details area of the debugger's Variables
and Expressions views supports word wrap, available from the
view drop-down menu.
|
Code assist in the debugger |
Code assist is available in many contexts beyond writing code in the Java editor:
|
Command line details | You can always see the exact command
line used to launch a program in run or debug mode by selecting Properties
from the context menu of a process or debug target, even if the
launch has terminated.
|
Stack trace hyperlinks |
Java stack traces in the console appear with hyperlinks. When you place the mouse over a line in a stack trace the pointer changes to the hand. Pressing the mouse button opens the associated Java source file and positions the cursor at the corresponding line. Pressing the mouse button on the exception name at the top of the stack trace will create an exception breakpoint.
|