Using Eclipse 3.

5
1.0 Introducing Eclipse
2.0 Installing and Starting Eclipse
3.0 Our First Eclipse Project
4.0 Code Editing Tools
5.0 Navigating Through Code
6.0 Java Source Generation
7.0 Javadoc
8.0 Resources
9.0 Exercise

Target Audience: this tutorial is geared toward the beginning Java programmer who has some experience with Java
programming from the command-line.

1.0 Introducing Eclipse

When you first learned how to write Java programs, you probably started by writing in a text file, compiling using the javac
command, then running your program from the command-line using the java command. This form of programming is what
we'll refer to as command-line programming, and follows the practice of edit-compile-execute. While command-line
programming has many advantages, it can be quite tedious. After all, your text editor doesn't usually provide much outside of...
well... editing. Professional developers, generally speaking, tend to gravitate toward what is called an integrated development
environment (IDE) for their programming. The idea of an IDE is to integrate many different tools into a single program (e.g.
code editing, compiling, running, file management, code navigation, documenting, etc.) Programming with an IDE can provide
some of the following advantages over command-line programming:

 Compiling is built-in. Whenever you hit "Save", your code is compiled for you.
 A controlled execution environment means that you can control how exactly your program will be executed without
changing what your current system is configured for (e.g. running your program using different Java virtual machines)
 A Graphical User Interface (GUI) provides immediate feedback on compile errors, warnings, and other problems with
your project.
 IDEs are highly customizable. From formatting and coloring preferences to programming in various languages and
technologies, IDEs are extremely extensible.
 Code editing and navigation is much easier because the IDE "understands" the language you're working with (you'll
understand more of what this means with a few examples).
 IDEs support large projects by providing many other tools not related directly to programming, but with software
development in general.

In this tutorial we'll be covering Eclipse, a professional-grade, open-source development platform for Java (and many other
languages!). We'll focus on some of the features found in Eclipse that are not found in command-line programming.

A note about audience. We will be assuming two different users of this tutorial:

 Home users: users working on their own machine, who can devote permanent space to their Eclipse work.
 Lab users: users working in public laboratories who cannot devote permanent space to their Eclipse work. Lab users
may need some special information specific to their lab, such as the proper location of their workspace. We may
defer to your lab instructor to get this specific information.

2.0 Installing and Starting Eclipse

Lab Users: your lab should already have Eclipse 3.5 (or similar version) installed. Start Eclipse the way your lab instructor tells
you to. Skip to the Starting Eclipse part.

Home Users: follow these instructions.

1. Go to http://eclipse.org and click on Download Eclipse.

2. Find the Eclipse for Java Developers link on the page. Click on the link for your operating system along the right-hand
side.

Figure 1: Downloading the Eclipse for Java Developers

3. Select a mirror and download the file. Make sure that you are downloading a zip file.
4. Once the zip file is downloaded, unzip the file to a location on your computer. I usually choose something like
c:\eclipse-3.4. Remember this location - we will refer to this location as <YOUR INSTALL LOCATION>.
5. Start Eclipse by executing <YOUR INSTALL LOCATION>/eclipse/Eclipse.exe

Starting Eclipse

When you first start Eclipse, you will be asked to select your workspace. Like this:

Choosing a Workspace

The Eclipse workspace is a permanent location for all of your work.

 Lab users: choose the location of your workspace according to what your lab instructor tells you. Please note that
your work may not be backed up on laboratory machines, so be sure to copy your workspace to a safe place before
logging out.
 Home users: choose any location of your workspace on your hard drive. I usually choose something like c:\workspace.

The first time you start with a fresh workspace, you will be shown a Welcome view. Close the Welcome view according to the
following figure
Figure 2: Closing the Welcome Screen

In most Eclipse versions, your interface looks like Figure 3. This is called the Java Perspective (which will have this icon in the

upper-right: ). Feel free to mess around with the windows (called "Views"). If you want to reset the perspective to
how it originally looked, go to Window > Reset Perspective. If you are not in the Java perspective, use Window > Open
Perspective > Other... > Java (NOT Java Browsing!)

Figure 3: The Java Perspective

3.0 Our First Eclipse Project

Now that we have our Eclipse workspace set up, let's set up our first project. An Eclipse project is a grouping of files, which are
all part of one program. For example, you can have many Java files, the compiled Java .class files, the project's website, and
other resources in a single Eclipse project.

Let's start by creating a project called HelloWorld.

1. Right click in the Package Explorer ( ) and select New > Java Project as shown in Figure 4.

Figure 4: Creating a new Java Project

2. A window will pop up where you can change setting related to your project. Place HelloWorld as the name of your
project. The other default settings are okay. Make sure that you select the option to Create separate folders for
sources and class files.

Figure 5: Configuring your new project

 3. Select Finish. You should see your new project appear in the Package Explorer. Click on the plus sign ( ) to expand
and look inside your project. Note: for Mac and Vista users, this may be an arrow ( ) instead of a plus sign.

Figure 6: Examining your new project

4. Notice the src folder in your project. This is where we'll put all of our Java classes. If you do not have a src folder, right
click on the project name and select New > Source Folder. In the resulting dialog, name the folder src. A bin folder
(which will store all your compiled class files) will be automatically created for you.

So let's create a Java class called HelloWorld.java. Right-click on the src folder, and select New > Class.
Note: in this case, we are creating a project called HelloWorld and a class HelloWorld. Class names and project names do NOT
need to be the same. Typically a project will have many classes, and none of the classes should have the same name.

1.
Figure: 7: Creating a new Java class

5. In the Name box type HelloWorld for the name of your class (you do not need the .java extension). Also, check the
box that says public static void main(String[] args) as method stub that you would like generated. Your screen should
look like this.
 Figure 8: Naming and Configuring the New Class

6. Hit Finish. Eclipse generated a file called HelloWorld.java, and placed stubs for comments and the main method. A
Java editor has also been opened.

Figure 9: Editing our new class

7. Place the print statement for the string literal "Hello, World": System.out.println("Hello, World"); . Press the Save (
) button at the top (or hit Ctrl+S). If you type the print statement into the editor, you may notice a red show up to
the left of your line. Eclipse is trying to compile your code as you type, and since you have an uncompleted statement,
a compilation error is shown. Just ignore the red for now, and focus on finishing your statement. If you have a red
after completing your statement, then you can investigate the compiler error.
 Figure 10: Adding our print statement and saving.

8. When you just hit Save there, that compiled the program - equivalent to running the command javac HelloWorld.java
on the command-line. If there are any compile errors, they will pop up in the Problems view ( )
after you hit Save. Additionally, the line of code with a compiler error will have a red to the left, and there will be a
red line under the code. If there are no compile errors, then right-click on HelloWorld.java in the Package Explorer
and select Run as... > Java Application.

Figure 11: Running a Java program

9. The output to your program gets printed out to the Eclipse Console view ( ). We just ran our first
Java program in Eclipse!! If you do not see the Console view, select Window > Show View > Console. You may need to
rerun your program for the output to display as seen in Figure 12.
 Figure 12: Viewing console output

4.0 Code Editing Tools

Now that we can create and run a program, let's create a larger program to demonstrate some of Eclipse's powerful code
editing tools. As we create this program, we will cover the following features:

 Quick Fix
 Auto-complete
 Code Templates and Formatter

Creating a New Project

Multiple projects can exist in a single Eclipse workspace. Let's create a new project called MovieInventory that will keep track of
our DVDs. Inside your project, create a class file called MovieInventory. MovieInventory will keep track of the movies in our
collection. Do not give MovieInventory a main method (typically most classes in a larger application will NOT have main
methods. You only need one main method to start your program.)

Quick Fix

The Eclipse editor knows a lot of common errors. By storing patterns of common errors, Eclipse can give you a "Quick Fix" for
your problem.

1. First, let's define a field (instance variable) in our MovieInventory class to hold all of the Movies in our collection.
Place this at the top of your MovieInventory class and then hit Save :

private Movie [] movies;

Figure 13: Adding a field to the MovieInventory class to keep track of Movies.

2. Looks like we've got a compiler error. (Remember that saving automatically compiles our code.) You can tell this in
several ways:
o There's a red squiggly under our new variable
o There's a little red X along the left-hand side of editor:
o The Problems view at the bottom shows an error:
 Figure 14: The Problems View

The compiler error states: "Movie cannot be resolved to a type." This error means there is no class in the
JDK named Movie that we can create an object from. However, we would like to use a Movie object to keep
track of all the information about a Movie. Therefore, we're going to have to create our own Movie class.

HOWEVER! You may also notice a little lightbulb on the error icon: . This means that Eclipse has an idea
for how to fix your problem. In our case, all we need to do is create a Movie class. Let's let Eclipse do this for
us.

3. With your text cursor anywhere inside the red squiggly, hit Ctrl + 1 (that's the number ONE; Mac users, try Apple + 1).
Up pops the quick-fix menu:

Figure 15: The Quick Fix Menu

4. Notice all of the options here. Select the first option, to create class 'Movie' by hitting Enter. Eclipse will bring up a
wizard for creating a new class. The class name will be entered for you. Hit Finish to create the new class.
 Figure 16: Create a Movie Class

5. Let's switch back to our MovieInventory class to keep working on our inventory. Switch back to the
MovieInventory.java editor (Ctrl + F6 is the keyboard shortcut, Mac users try Fn+Apple+F6).

The Eclipse Quick Fix tool can be very powerful, but also limited to very common and easily-solvable problems. The Quick Fix
will only work on compile errors, not logic errors, for example. Quick Fix may not always fix your code exactly how you want to,
so it's not a good idea to completely rely on this feature (it's only meant to save you time, anyway). Some common fixes are
finding an import, creating a class/method/variable, public/private access, fixing parameters in a method, and many others.

Using Quick Fix for "Error-Driven Development"

One way to use Quick Fix is to first write your code ignoring all of your declarations. If you want to call a class you haven't
written yet, just use it how you plan on using it, then use quick fix to do all of the declarations. It takes some getting used to,
but allows you to write code very quickly in the end because you don't have to do so many declarations. I find myself writing
code in this way because I can simply write what I am currently thinking about without having to stop and deal with details that
can be Quick-fixed anyway. You might find that this way of writing code is not so different from writing pseudocode first!

Auto-Complete

1. We have a field that can hold our movie inventory. Now, we need to initialize our field to hold 10 movies. We should
create a constructor for MovieInventory to initialize our field. Eclipse can simplify the creation of our constructor by
using auto-complete.
2. Constructors have the same name as the class. On a new line, start typing in MovieInventory. You only need to type in
'M,' like this:
 Figure 17: Beginning to create a constructor

3. Now press Ctrl + Space. Your text cursor should be just to the right of the M (as if you were in the middle of typing the
variable MovieInventory). Here's what the menu looks like:

Figure 18: Auto-complete menu

4. This is the auto-complete menu. Note the MovieInventory default constructor is at the top of the list. Hit Enter to add
the constructor's header.
5. We can also use auto-complete to help us remember variable names. In the constructor, we want to initialize our
Movie's array. If we start typing in the name of the array, and then hit Ctrl + Space, Eclipse will help us by suggesting
variable names. Additionally, when we go to fill in the size of the Movie array, we can substitute in a constant name
for the value we want to use. Quick Fix can then be used to create the class constant for the size of the array. When
you are done, your code should look like the code in Figure 19.
Figure 19: Completed MovieInventory constructor

Hint
Any time you want to finish something that you think Eclipse can guess, it's worth hitting Ctrl + Space to see if it does. Eclipse
will find things like method names, variables in the current scope, class names, or even make suggestions for a variable you're
declaring! The idea is that you don't have to remember everything about the program you're writing. You can select the options
with your mouse, but it's probably faster to use the arrow keys and the Enter key.

Code Templates and Formatter

Eclipse provides several code templates for commonly used methods and statements. Additionally, Eclipse can help you keep
your code well formatted (which will help you lose less style points on your programming assignments).

1. If you have a main method in your MovieInventory class, please delete it.
2. With your text cursor in the program, start typing the word main and hit Ctrl+Space.

Figure 20: The Main method code template

3. There should be a code template (with the following icon: ) for the main method. Hit Enter to select it.
4. Voila! There's our main method! Note that the text cursor lands in the middle of the method so you can just start
typing code.

Figure 21: The Main Method

5. Eclipse has another helpful code template called sysout. Invoke the sysout template the same way you did the main
template. (If you type all of sysout before hitting Ctrl + space, the menu doesn't pop up because there's only one
option!).
6. Now that we have our System.out.println(); call from the code template, type a String literal and ensure that your
program prints it when you run MovieInventory.

Figure 22: System.out.println

7. Once you know that your program works, take a look at your code. Methods should be indented within classes, and
statements should be indented within methods. If your code does not follow proper indentation and before you start
formatting yourself, hit Ctrl + Shift + F (or go to the Source > Format in the menu; Mac users try Apple + Shift + F).
8. If you want to add/edit code templates or the way your code gets formatted, go to Window > Preferences (Mac Users
it's Eclipse > Preferences).
o For code templates, go to Java > Editor > Templates. You can also start typing "Code templates" in the top
text box to find the menu.
o For the formatter, go to Java > Code Style > Formatter. You can also start typing "Formatter" in the top text
box to find the menu
 Figure 23: Eclipse Preferences for Code Templates

Here are a few other key code templates:

 There are several for code templates that will create a for-loop for you
 The foreach template will search upward from your current location and find the nearest Iterable type and create an
enhanced for-loop over it.
 The test code template will create a JUnit 3 test method for you
 Typing /** before a method will generate Javadoc, inferring the parameters to your method

5.0 Code Navigation Tools

Eclipse provides some tricks for traversing through code. In this section we'll cover:

 Going to the declaration by clicking

 Package explorer

1. Go to your MovieInventory.java program. Hold down the Control key and hover your mouse over the declaration of
Movie. The Movie should turn into a hyperlink.
Figure 24: Turning class declarations into hyperlinks

1. With Control still held down, click on the Movie hyperlink (Mac users try the Apple key). This will take you to the
Movie class.
2. In general, if you Ctrl + Click on something, you'll go to where it is defined. So clicking on the Movie() constructor call
will go to the class declaration (if a constructor were defined for Movie, then you would go to the constructor). This
can save you a lot of time of finding where something is defined. If you cannot get it to work, make sure you've got
the following things:
o Make sure the current file is saved. Sometimes compilation will refresh what Eclipse knows about each
class.
o Make sure that you have all of your compile errors fixed.
o Sometimes you need to hold down the Control key for a half-beat before the hyperlinks show up.
o If you hover too long, the hyperlinks go away.

3. The Package Explorer can also be a very helpful view for managing large projects. Notice
that we have our two classes in the Package Explorer already.

Figure 25: Our Package Explorer

4. Use the plus sign (or arrow on Vista machines) to expand each element of our src folder. Here we see all of
methods, instance variables, and static variables of our class.

Figure 26: Expanding each part of our classes

6.0 Java Source Generation

Eclipse provides source generation of commonly used code. You will typically want to use source generation when creating
plain old java objects (POJOs) or when you want to override methods from the Object class.
Source code generation is only useful if you have specified data (or state) for your object. Let's create some state for our Movie
object. A Movie should keep track of its title, release year, genre, and rating. Additionally, a Movie object should be immutable.

1. Add the following code to create fields (instance variables) for Movie's state.

Figure 27: Movie's state

2. Each of the fields has a yellow warning next to the line of code. The warning states that the field is never used locally.
The lightbulb next to the warning triangle let's us know there is a quick fix. One will delete the field. Another will
generate the getter (accessor) and setter (mutator) for the field. Typically, when creating fields you will want to
generate getters and setters as appropriate to your class.

We want to make our Movie class immutable. Therefore, we do NOT want to create setters. The Quick Fix option only provides
functionality for creating BOTH getters and setters. Additionally, the Quick Fix option only works on one field at a time. We can
use another piece of Java's built in functionality to provide a more general code generation that also allows for selection of just
getters.

Right click anywhere in the Editor view. Select Source > Generate Getters and Setters....
 Figure 28: Source Context Menu

All of the fields in the Movie class are displayed. We can press the Select Getters button to the right to generate getters for all
of the fields. Using the arrows will display which of the methods will be created for each field. If you would like to save your self
a little more time, select the check box next to Generate method comments. Additionally, you may want to change the
insertion point so that the new methods are positioned at after the fields. Click Finish when you are done selecting options. The
newly generated code will display in the Editor view. You'll want to save Movie, which will remove the earlier warning
associated with each field.
 Figure 29: Generate getters and setters

Check that the getter methods were properly generated and added to the Movie class.
 Figure 30: Generated setters

3. Now that we've created state and getter methods for our Movie class, we'll need to provide a mechanism for creating
a new Movie object. One way we could do that is by using the default constructor and providing setter methods, but
that does not guarantee that a Movie object will be fully created by a user and violates our requirement of
immutability. A better way to create a Movie object is through the use of a constructor where the user passes in
values for each of Movie's fields.

Like the generation of getters and setters, Eclipse will generate a constructor for us. The file that you want to add the
constructor to (Movie) should be displayed in the editor view. Right click in the editor and select Source > Generate Constructor
using Fields....

You will select which fields you want to include in the constructor. Just because you have a field in your class does not require
that a value is passed in as a parameter to the constructor, so you can leave fields unchecked. You should handle initialization
of those fields within the constructor to the appropriate default value. If you would like to save yourself a little more time,
select the check box next to Generate constructor comments. Additionally, you may want to change the insertion point so that
the constructor is positioned above your getter methods. Select OK.
 Figure 31: Constructor code generation

Check that the constructor was added to your Movie class.

 Figure 31: Generated Movie Constructor code

4. The Object class is the parent of all Java objects, and provides many useful methods that we use frequently when
developing software: equals(), hashcode(), and toString(). However, Object's implementation of these methods may
not be as robust as what we may want in our code. Eclipse can help us generate overridden versions of these
methods for use in our objects.

The equals() method compares two object's to determine if they are equivalent. The default implementation of the equals()
method is to compare the location's of the objects in memory. If the objects are in the same location, then they are the same
object, and therefore equal. However, we may want to define object equality differently. Typically, objects are considered the
same if some or all of their fields have the same values. We can override the equals() method to define that two Movies are the
same if their fields are equivalent.

Eclipse requires that if you override the equals() method using code generation that you also override the hashcode() method
using code generation. This is to ensure that an object's hash is the same if the two objects are equal (you'll discuss hashes in
data structures), and is an invariant of the Java programming language.

To override the equals() and hashcode() methods, ensure that the class you're generating the methods in is active in the Editor
view. Right click in the Editor, and select Source > Generate hashcode() and equals(). In the resulting dialog, select which fields
are required for object equality. If you would like to save your self a little more time, select the check box next to Generate
methods comments. Additionally, you may want to change the insertion point so that the new methods are positioned at the
bottom of your getter methods. Click OK.
 Figure 32: Generate equals() and hashcode() methods

Check that the methods were generated in your source. Don't forget to save your changes!

Figure 33: Generated equals() and hashcode() methods

Top | Contents

7.0 Javadoc

Commenting your code is important! Comments describe what the code is for. At a minimum, you should comment your class,
fields, and methods. Java provides a tool, called Javadoc, that will generate a set of webpages that display the comments for
your code.

Every time you use the Java API, you are using webpages generated with the Javadoc tool. Kindly, the Java developers have
done an excellent job of commenting the class files in the Java SDK. You can then use the API to find classes and methods that
may help you implement the code that you're implementing. You should return the favor to those that may use your code by
providing comments. By providing the comments in a Javadoc format, you'll be able to generate an API for your code that will
benefit future programmers.

After you have written your Javadoc in your class files, you will want to run the Javadoc tool on your code. You can run Javadoc
by selecting Project > Generate Javadoc.

In the resulting dialog, you will need to configure the Javadoc command, if you don't already have the command configured. To
configure your Javadoc command, select the Configure button. Browse to the location where you installed your JDK. The
javadoc tool is in the bin folder.

Additionally, you can select which projects/packages/classes/and files you want to run Javadoc on. Eclipse will default to
generating your Javadoc in a new folder called doc within your project file.

Figure 34: Generate Javadoc

Selecting Next will allow you to edit additional details about the generated Javadoc, but the default settings should be sufficient
for the Javadoc you'll create for this class. Selecting Finish will generate the Javadoc. If you don't have a doc folder in your
project already, you will be prompted to create the destination folder. Select Yes To All. When the Javadoc has been created,

you will need to refresh your project listing in the Package Explorer . You can do this by selecting
your project and pressing F5. When you open your project, you should see a doc directory. Selecting index.html within the doc
directory will open a Browser window in your editor with your newly generated Javadoc.

Figure 35: Generated Javadoc

Any time you update your Javadoc, you should regenerate the html files.