Debugging in Eclipse
3. Debugging in Eclipse
3.1. Setting Breakpoints
For example in the following screenshot we set a breakpoint on the line
Counter counter = new Counter();. 
3.2. Starting the Debugger
To debug your application, select a Java file which can be executed, right-click on it and select ? .
After you have started the application once via the context menu, you can use the created launch configuration again via the button in the Eclipse toolbar.
If you have not defined any breakpoints, this will run your program as normal. To debug the program you need to define breakpoints.
If you start the debugger, Eclipse asks you if you want to switch to the Debug perspective once a stop point is reached. Answer in the corresponding dialog.
Afterwards Eclipse opens this perspective, which looks similar to the following screenshot.
3.3. Controlling the program execution
You can use the F5, F6, F7 and F8 key to step through your coding. The meaning of these keys is explained in the following table.
Table 1. Debugging key bindings / shortcuts
| Key | Description |
|---|---|
| F5 | Executes the currently selected line and goes to the next line in your program. If the selected line is a method call the debugger steps into the associated code. |
| F6 | F6 steps over the call, i.e. it executes a method without stepping into it in the debugger. |
| F7 | F7 steps out to the caller of the currently executed method. This finishes the execution of the current method and returns to the caller of this method. |
| F8 | F8 tells the Eclipse debugger to resume the execution of the program code until is reaches the next breakpoint or watchpoint. |
The following picture displays the buttons and their related keyboard shortcuts.
The call stack shows the parts of the program which are currently executed and how they relate to each other. The current stack is displayed in the Debug view .
3.4. Breakpoints view and deactivating breakpoints
To deactivate a breakpoint, remove the corresponding checkbox in the Breakpoints view . To delete it you can use the corresponding buttons in the view toolbar. These options are depicted in the following screenshot.
If you want to deactivate all your breakpoints you can press the button. If you press it again, your breakpoints are reactivated. This button is highlighted in the following screenshot.
3.5. Evaluating variables in the debugger
Use the drop-down menu to display static variables.
Via the drop-down menu of the Variables view you can customize the displayed columns. For example, you can show the actual type of each variable declaration. For this select ? ? .
3.6. Changing variable assignments in the debugger
3.7. Controlling the display of the variables with Detail Formatter
toString() method to determine how to display the variable. You can define a Detail Formatter in which you can use Java code to define how a variable is displayed.
For example the
toString() method in the Counter class may show meaningless information, e.g. de.vogella.combug.first.Counter@587c94. To make this output more readable you can right-click on the corresponding variable and select the entry from the context menu. 
Afterwards you can use a method of this class to determine the output. In this example the
getResult() method of this class is used. This setup is depicted in the following screenshot. 
4. Advanced Debugging
4.1. Breakpoint properties
You can for example specify that a breakpoint should only become active after it has reached 12 or more times via the Hit Count property.
You can also create a conditional expression. The execution of the program only stops at the breakpoint, if the condition evaluates to true. This mechanism can also be used for additional logging, as the code that specifies the condition is executed every time the program execution reaches that point.
The following screenshot depicts this setting.
4.2. Watchpoint
You can set a watchpoint by double-clicking on the left margin, next to the field declaration. In the properties of a watchpoint you can configure if the execution should stop during read access (Field Access) or during write access (Field Modification) or both.
4.3. Exception breakpoints
You can configure if the debugger should stop at caught or uncaught exceptions.
4.4. Method breakpoint
You can configure if you want to stop the program before entering or after leaving the method.
4.5. Breakpoints for loading classes
To set a class load breakpoint, right-click on a class in the Outline view and choose the option.
Alternative you can double-click in the left border of the Java editor beside the class definition.
4.6. Step Filter
4.7. Hit Count
4.8. Remote debugging
To enable remote debugging you need to start your Java application with certain flags, as demonstrated in the following code example.
java -Xdebug -Xnoagent
-Djava.compiler=NONE
-Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=5005
In you Eclipse IDE you can enter the hostname and port to connect for debugging via the ? menu.
Here you can create a new debug configuration of the Remote Java Application type. This configuration allows you to enter the hostname and port for the connection as depicted in the following screenshot.
Note
Remote debugging requires that you have the source code of the application which is debugged available in your Eclipse IDE.4.9. Drop to frame
This allows you to rerun a part of your program. Be aware that variables which have been modified by code that already run will remain modified.
To use this feature, select a level in your stack and press the button in the toolbar of the Debug view .
Note
Fields and external data may not be affected by the reset. For example if you write a entry to the database and afterward drop to a previous frame, this entry is still in the database.for loop, the field result is not set to its initial value and therefore the loop is not executed as without resetting the execution to a previous point. 
5. Exercise: Create Project for debugging
5.1. Create Project
de.vogella.combug.first. Also create the package de.vogella.combug.first and create the following classes. package de.vogella.combug.first;
public class Counter {
private int result = 0;
public int getResult() {
return result;
}
public void count() {
for (int i = 0; i < 100; i++) {
result += i + 1;
}
}
}
package de.vogella.combug.first;
public class Main {
/**
* @param args
*/
public static void main(String[] args) {
Counter counter = new Counter();
counter.count();
System.out.println("We have counted "
+ counter.getResult());
}
}
5.2. Debugging
Counter class. Debug your program and follow the execution of the count method. Define a Detailed Formatter for your
Counter which uses the getResult method. Debug your program again and verify that your new formatter is used. Delete your breakpoint and add a breakpoint for class loading. Debug your program again and verify that the debugger stops when your class is loaded.
6. Thank you
Please help me to support this article:
 |
7. Questions and Discussion
8. Links and Literature
8.1. Source Code
8.2. Debugging Links
http://www.eclipse.org/articles/Article-Debugger/how-to.html How to develop your own debugger
8.3. vogella Resources
Android Tutorial Introduction to Android Programming
GWT Tutorial Program in Java and compile to JavaScript and HTML
Eclipse RCP Tutorial Create native applications in Java
JUnit Tutorial Test your application
Git Tutorial Put everything you have under distributed version control system
Source : http://www.vogella.com/articles/EclipseDebugging/article.html
download file now