Step 4: Using the Debugger to Debug the Application

Previous

Next

Now that you have created an application that will run the UI, you will practice some simple debugging in JDeveloper as practice for debugging more complex applications.

You'll probably want to set a least one breakpoint before you start debugging, but it is not necessary. Setting a breakpoint in your source code instructs the debugger to pause at an exact location in the source code while debugging.

If you do not set a breakpoint, you can:

• Start the debugger and then click Pause to stop it.

  Or

• Click Step Into, in which case the debugger will stop at the first executable line of code in your program

Once you have paused the debugger, you can control specifically how you want it to reenter your code, using the Debug menu, toolbar icons, or keyboard equivalents. The step operations available to you include:

• Step Into  executes a single program statement at a time. If the current execution point (indicated by an arrow, ) is located on a call to a method, the Step Into command steps into that method and places the execution point on the method's first statement.
• Step Over  enables you to execute program statements one at a time. However, if you issue the Step Over command when the current execution point (indicated by an arrow, ) is located on a method call, the debugger runs that method without stopping (instead of stepping into it), then positions the execution point on the statement that follows the method call.
• Step Out  will finish executing a method call you have stepped into, and return to the next executable line in the calling method.

Notes:

• You can set the debugger's start option by clicking from the toolbar.
• You cannot start debugging by clicking Step Into or Step Over. Choosing either of these options will only cause stepping on an already-started debugging process.
• You can also click Terminate in the toolbar at any time to exit the debugger session.

To set a breakpoint in your source code:

1. Open Frame1.java in the Code Editor.

   If the file is closed, double-click its source node in the Navigator to open it in its default editor.

   Your source code should still be open. If it is, to bring the Code Editor for Frame1.java to the foreground, you can double-click its node in the Navigator, or select its entry (in this tutorial, marked with a number 2) in the document bar. Unless you have explicitly changed their numbering, any files you have opened are displayed in the document bar in the order you opened them.

You can also cascade or tile your editor windows and navigate between them this way. To do so, from the main menu, choose Window | Cascade or one of the two tile options.

2. In the gray margin of the editor, line numbers appear. Click the number beside the first line containing an if statement.

   Notice that appears in place of the line number, indicating that an unverified breakpoint has been set at this line in the source code. To remove a breakpoint, just click and the line number reappears.

3. Display the Breakpoints window by choosing View | Debug Windows | Breakpoints. This window displays all the breakpoints set for this workspace or project.

To run the debugger on your source code:

1. Click Debug in the toolbar to start the debugger.

   Note: If the Default Run Target dialog is displayed, you must select a Java class with a main method to use as the default. In this case, you would select the Application1.java class you created earlier. Click Browse and navigate to \Workspace1\Project1\src\package1. Select Application1.java and click Open. On the Default Run Target dialog, click OK to continue debugging.

A number of things now happen:

• A new tab opens in the Log window for the debugger process, indicating that the debugger has connected to the local process.
• Several debugger windows are automatically displayed including:
  
  
  • Smart Data—In the lower-right corner of JDeveloper, this window displays all arguments, local variables, and static fields for the current method. Only the data that appears to be relevant to the source code that you are stepping through is presented.
  • Data—In the lower-right corner of JDeveloper, this window displays the arguments, local variables, and static fields for the current context, which is controlled by the selection in the Stack window. You may have to click on the Data tab to see it.
  • Watches—After you enter a watch expression by choosing Add Watch from the context menu, the Watches window displays the current value of the expression. As your program runs, the value of the watch changes as your program updates the values of the variables in the watch expression.
  • Stack—A window below the Navigator displays the call stack for the current thread. When you highlight a line in the Stack window, the Data window, Watches window, and all Inspector windows are updated to show data for the highlighted method.
    
    
2. When the application is run, select a status code from the combo box and click OK. Nothing happens because the code to display the status text in the text field is never executed. In the Code Editor, appears in the margin at the line where you set your breakpoint indicating the current execution point.
3. Click Step Over  in the toolbar to step to the next line of code. The moves to the next if statement. The verified breakpoint icon appears, indicating that your breakpoint is now validated.

   If you continue clicking Step Over, you will continue moving through the code to the next executable line, stepping over, rather than into, the method calls.

4. In the Smart Data window, expand the this and this$0 nodes. You can see each of the components and the classes they are based on. If you expand these further, you can see their properties and the property values.
5. Click Resume  to continue running the rest of the program.

   If another breakpoint was set, the program continues to that point. Without breakpoints, the debugging process will complete when you terminate the application being debugged.

Once your program has completed, the debugger process exits. When you close the application, a message to this effect appears in the Log tab within the Log window.

Now that you have practiced debugging, you are ready for the next task, Step 5: Compiling and Running the Application.