An Introduction to the Eclipse IDE
Pages: 1, 2
Now that we have the directory structure in place, we can
begin adding code to our project. We'll divide our
calculator program into three different files:
Calculator.java. Grab the
.zip archive and place these files in
the com/devious/calculator directory. Use
File->Refresh to update the Eclipse project.
CalcPanel.java handles most of the user interface
for our calculator.
Calculator.java handles setup
and launching of the GUI. Most of the important work happens in
CalModel.java, which implements the actual "mechanics" of
our calculator: responding to events, performing numerical
calculations, updating the display, and so on. The easiest way to
explore the code is by switching to either the Java perspective
or the Java Browsing perspective. Use the Open Perspective
item in the Window menu or click the Open button
on the perspective toolbar.
As you use the Package Explorer to browse the source code, you may notice that the Outline view seems a bit superfluous. You can click the X in the upper right corner of the Outline view to close it. Should you want to see it again, you can use the Window->Show View->Outline menu item to display it again. Those interested in a multi-paned source code viewer a la Smalltalk should give the Java Browsing perspective a try.
Running Code and Debugging
So you've managed to download and install Eclipse, create a Java project, and add the folders and files needed for a simple application. Now it's time to see the application run. You'll need to use the Java perspective to complete the steps necessary to run the app:
- From the Run menu, select the Run... item.
In the wizard dialog which appears, select "Java Application" from the list of Launch Configurations, then click the New button.
Enter Calculator as the Name for the new configuration.
Click the Search... button and select
Calculatoras the Main class, or simply enter com.devious.calculator.Calculator in the text entry box.
Click the Run button to save the configuration and run the application.
Once you've created a launch configuration for the application, you can run it again using Run->Run History menu item or the Run button on the toolbar. If you spend enough time playing with the calculator, you'll notice that while it works pretty well, it does seem to have one major flaw: it won't do subtraction! Time to fire up the Eclipse source-level debugger and find the problem. If you've been following along with the examples, you should be able to debug the application using the same launch configuration defined earlier. Select Run->Debug History->Calculator to launch the application in the debugger.
When you launch your application for debugging, Eclipse automatically switches to the Debug perspective:
Since our problem seems to center around the subtraction
function, we'll set breakpoints in the event handler for the
minus key and the equals key. First, we need to switch
to the editing tab for the
CalcPanel class. (If you
don't have an open tab for
CalcPanel, you'll have to
switch back to the Resource or Java perspective, open the file
there, then switch back to the Debug perspective.)
Outline view to select the
method. Scroll down a few lines until you see the
case statement for the minus key (line 126). If you
double-click in the left margin at this line, you'll see that
Eclipse sets a breakpoint there. Scroll down a bit more and set
another breakpoint on the call to
in the handler for the equals key (line 138).
Next, switch to the calculator window and click some of the
buttons. Something like
2 4 6 - should do the trick.
Once the debugger hits the breakpoint, you can use the buttons
in the toolbar for the Debug view to step into, over, or out of
If we step into the
setOperation method, we see
that it just saves the operation code to the
pendingOp field. Press the Resume button on the Debug toolbar to continue the execution of the program.
Tip: A common mistake for new Eclipse users is to press the Debug or Run buttons on the main toolbar rather than the Resume button. This will launch another copy of your application, rather than continuing the current one.
Now, click a few more buttons (e.g. "1", "2", "3") and then
the equals key. Once we step into the
calculate method, the problem is obvious: someone copied the code from the
OP_ADD case but didn't edit it to properly perform a subtraction rather than an addition. Problem solved!
Hotswap Bug Fixing
If you happen to be running your application using a 1.4 JVM, there's one final step to our debugging example. Rather than exiting the app, changing the code, recompiling, and then starting another debugging session, we can fix the problem on the fly. With the debugger still running, change the problem line from:
setDisplay(previousValue + currentValue);
setDisplay(previousValue - currentValue);
Save the file, then press the Resume button to get the application running again. Use the calculator's C button to reset it, then try the same sequence of operations again. This time around, it works!
What we've just demonstrated is Eclipse's support for a new 1.4 feature called "HotSwap." The Java Platform Debugger Architecture (JPDA) now supports the ability to substitute modified code in a running application. This is particularly useful when starting your application, or getting to the point where it fails, takes a long time.
A Taste of Things to Come
One very attractive feature of Eclipse is the speed with which product bugs and deficiencies are addressed. While Eclipse 2.0.2 is the current version of the product, the Eclipse Group is actively working toward the release of Eclipse 2.1. Monthly "milestone" builds (M1, M2, M3, etc.) deliver the latest stable feature set from Eclipse 2.1 to interested users. Among the features included in the latest 2.1 M3 build:
- Customizable key bindings, including a set of Emacs-like bindings
- The ability to automatically turn
FIXME, and tagged comments in Java code into items in the Tasks list.
- Improved CVS support, including the ability to define "working sets" that limit the number of projects shown in the CVS Repositories view.
- New "hovers" in the Java editor, which can be used to show source code, Javadoc, or detailed error messages for a particular line of code or expression in a pop-up "tooltip" window.
- Support for several new refactorings
- A new Threads and Monitors view in the debugger, which allows you to determine which threads are holding locks, which threads are waiting, and other information necessary to track down problems in multi-threaded applications.
- Tighter integration with the Jakarta Ant build tool.
It is this last feature which makes Eclipse particularly well-suited to Java application development and, in particular, Web application development. Eclipse brings together all of the tools a developer needs to be successful at Web application development: an extensible IDE, a standards-based compiler, remote debugging, Ant-based builds, JUnit-based testing, and plug-ins for communicating with most application servers and EJB containers.
Scott Storkel is an experienced programmer with over twenty years of experience, including object-oriented systems for the last twelve years and building enterprise-class Java web applications for the last four years.
Return to ONJava.com.