This lab will walk you through the basic steps of editing, compiling, and running Java programs. For this purpose we will use an Integrated Development Environment (IDE) called Eclipse. There are other IDEs available to you. Some are listed on the Library page. But I recommend Eclipse as a development environment that can grow with you. It’s powerful enough to be a popular choice among professionals, but has enough built-in help features to aid the novice.

• Eclipse is available on PCs in the CS Dept laboratories and, if you are off-campus, on the CS Dept’s Virtual PC Lab machines.

• Eclipse can be run on the CS Dept’s Linux ssh servers (the command is “eclipse &”). Of course, being a graphical user interface, this requires you to be running X or NX.

• You can install Eclipse for free on your own Windows, Mac OS/X, or Linux PC.

  • First you will need to make sure that you have a copy of the Java Software Development Kit (JDK, also known as the J2SE). Note that Oracle distributes Java in two basic forms: the Java Runtime Environment (JRE) is the basic package needed to run Java applications and web applets that someone else has compiled and provided. You probably already have this, but you want the larger Java Development Kit (JDK) that provides the compiler and associated tools. Follow Oracle’s instructions to install this.

  • Then get Eclipse from the Eclipse Foundation. There are lots of variations available. I would suggest getting either the “Classic” or the package “for Java EE Developers”.

    Installation is usually no more involved than simply unpacking the Eclipse package into a folder of your choice.

  • Eclipse makes a very good development environment for C++ as well as Java - it supports the GNU g++ compiler. On Windows it supports both the MinGW and CygWin/X ports of g++. After you have worked with Eclipse for a while, you may want to add this support. Use the built-in “Install New Software…” dialog (under the Help menu) to search for “Programming Languages” add-ons. You would start with the packages “C/C++ Development Tools” and the “C/C++ Library API Documentation…”.

1. Start Eclipse. You will be asked where you want to keep your workspace. The workspace is where Eclipse will keep its records of all of your projects. You can, but don’t have to, keep your actual projects inside your workspace. In fact, I generally recommend against it for any but the simplest projects. For example you might have a workspace in your home directory ~/workspaces , but keep your projects organized by using a separate directory for each course: ~/coursework/cs250, ~/coursework/cs382, etc.

   If this is your first time running Eclipse, you will be taken to a Welcome page. Close that or click on the curved arrow on the right to enter your workbench.

   If you have just installed Eclipse on this machine, then edit the Preferences (under the Window menu) on your first run. Under “Java”, look at “Installed JREs” and make sure that it shows your JDK and that the JDK is checked to make it the default.

2. Choose a convenient directory ( not your workspace directory) where you want to keep a project. Copy the files Pie.java, PieSlicer.java, and PieView.java into that directory.

   (Do this outside of Eclipse, in whatever manner you find most convenient for creating directories and copying files.)

3. Now let’s create a project. Select “New->Project…” from the File menu or by right-clicking in the Package explorer pane on the left. Select “Java Project” and click Next.

   Give your project the name “Pie”. Clear the “use default locations” box and then browse to the directory where you placed those Java files.

   Under “JRE”, make sure that the JDK you installed is selected for the execution environment.

   • Your JDK may be shown as a “JavaSE”. The important thing is that it matches the version number that you installed.
   • If you are running Eclipse on a CS Dept Linux server, select “JavaSE-11”.

   Under “Module”, clear the checkbox to create a module-info.java file.

   • If it pops up a box later asking you to create that file, select “Don’t Create”.

   Accept the rest of the defaults, clicking Next until you come to Finish, then click that.

   A box may come up asking if you want to open the Java perspective. Click in the “Remember my decision box” and then click “Yes”. (You probably want to do this whenever you are asked about opening a new perspective).

4. At this point, you should be looking at something like the picture on the right.

   If you expand the listing, in your Package pane, you will see an entry for the “default package” and one for the system library. Expand the default package and you will see the three Java files that you had placed in the directory. Remember that, in Java, classes are organized into packages. If you don’t name a package to serve as the container, then the class is assumed to belong to the “default” package - hence it’s listing here in Eclipse, which organizes your code according to your package structure.

   By this time, Eclipse has probably already compiled all three files. You may see a couple of warnings down in the Problems area. You can expand the Warnings item in the Problems pane to see the resulting messages. These should be some technical warnings about the lack of a serialVersionUID, which is a technicality that we really don’t need to worry about.

5. Double-click on Pie.java to open it in the editor. Let’s introduce a simple error into the code. Look for a line that mentions Color.red and change “red” to “maroon”. A small red marker will appear to the left of this statement to indicate that an error has been detected. To the right, another red marker will appear to show roughly how far down in the file this error is located. Hover your mouse over the red marker on the left. A tip should pop up stating that “Color.maroon cannot be resolved”. In other words, the class Color does not contain a constant named “maroon”.

   Of course, at this stage in your Java programming studies, you might not know what color names are provided by that class. But Eclipse can tell you. Delete the “maroon”, leaving your cursor just after the ‘.’ in that line. Hit Ctrl-space to request help, and you will be given a list of all constants and functions provided by the Color class that have the appropriate data type to be used here. You can scroll through the list and pick one (Don’t pick green, though.) The red error markers should disappear once you have done this.

   Save your changes via the File menu or via the floppy disk icon (how dated!) in the toolbar.

6. When you save, the code is actually compiled. This compilation may find errors not detected by the editor’s on-the-fly checking. If so, you will see red error markers appearing both in the editor window and in the Package browser on the left. To see this effect, move down to the draw function and put a “2” after the “w” to change the name to “draw2”. This is a perfectly legal change to make, so there is no initial complaint from Eclipse. Now save the file again.

   Notice that a red mark appears in the Package browser next to the PieView.java. There is also now an Errors section in the Problems tab at the bottom of the page. Expand the error listing and double-click on the error message there. The editor immediately takes you to the location of that error, in PieView.java. Unsurprisingly, perhaps, the error occurs at a call to the “draw” function, which, after our change, no longer exists.

   Move your mouse over the error marker to the left of the draw() call. Hovering over that location causes the error message to pop up. We’ve seen that before. But now left-click on that error marker. Eclipse actually offers suggestions on how to fix the error, And they are actually good suggestions! (How cool is that?) One suggestion is to change the call to “draw2”. The other is to add a new function named “draw” to the Pie class. Either of these is a perfectly reasonable suggestion. Choose the option to change to “draw2”. Depending on your operating system, you might select this either by using the arrow keys to highlight it and then hitting Enter, or by simply clicking on it. Eclipse makes the suggested change immediately.

   The error markers disappear from the editor, although one remains by the file name in the Package browser. Save the changes made to this file, and that one goes away as well. At that time, the listing in the Problems area also disappears.

7. Try using the same technique to get rid of those two nagging warnings. Double-click on each warning message in the Problems area to go to the code location with the warning. Left-click on the yellow warning marker on the left, and select one of the actions marked with the green plus sign to correct it. Save your changes, and savor the delight of a completely empty Problems listing!

8. Now let’s run the program. The main function for this program is in PieSlicer.java. Right-click on this in the Package browser and select “Run As…” “Java Application”. You should see a small window pop up with a circle and a couple of buttons. Move your mouse around inside the circle a bit, and try the buttons. It’s nothing spectacular - just a bit of fluff for us to play with in this lab. Close the window to kill the program.

   You can now run the program again from the run button (usually a white triangle within a green circle) in the toolbar. Actually, because this is a simple project, you could probably have used that the first time. But what this button normally does is to remember the last program that you ran within a project. So if you have multiple “main” functions in a project, you want to use the right-click menu the first time you want to run one.

9. Now let’s add a new class to the project. In the Package browser, right-click on the default package and select New…Class. A dialog box will pop up offering you a number of options for your new class. Put “Filling” in the Name box, select Generate Comments, then click Finish.

   A basic class template will be set up in the editor.

   Click inside the comment, at the end of the line just above the @author tag. Hit Enter and add the description “What’s the stuff inside the pie?”.

   Then click on the line between the “{ }” and type

   public String filling = "rhubarb";
   public Pie myPie;
   

   With the cursor positioned anywhere inside that line, you can correct the indentation with Ctrl-I (or choose “Correct Indentation” from the Source menu.

   It’s worth taking a moment to look at the Source menu. There’s lots of options for controlling formatting and appearance of your code. You can do a quick cleanup after you have typed a lot by using Ctrl-A to select all the code in your file, then choosing Format from the Source menu to reformat the whole thing.

   You can also find some help in generating code. For example, one of the entries in the Source menu is Generate toString(). Later, you’ll see that I believe that almost every class should have this function, as it is extremely useful in debugging. So try selecting it, check the “Generate method comments” box, and click OK.

   That’s kind of nice, isn’t it? In fact, go ahead and save your changes to that file. Then return the Pie.java file, click anywhere inside the Pie class, and generate a toString function for this class as well. Save the result.

10. Let’s do something similar for the Pie class. Edit Pie.java. Use the Source menu to generate a toString() function for this class. Save your file, and run the program again. Notice that the display at the top has changed. It has actually been showing the results of Pie.toString() all along. However, the default toString() function isn’t all that useful. Now we have replaced it with one that,although not particularly well formatted for this application, still shows a great deal more useful information.

11. While still running the program, use the buttons to change to colors of the pie segments. Note that the toString() display changes to reflect the colors that you have selected.

12. Exit Eclipse. It will save your project information so that, when you return and run Eclipse again, as long as you select the same workspace you will find your project waiting for you. (Note that, although we chose in this example to store the code for this project outside of the workspace, the workspace is still responsible for remembering that this project exists and where we keep it.)

    We’ll return to this program in future labs.

In an earlier Lab, you saw that we could use a single .jar file as a transport mechanism for all of the .class files that make up an entire program. In this lesson, you saw how to create Jar files from the command line. We can also use Eclipse to create Jar files.

1. Restart Eclipse.

2. Right-click on your Eclipse Pie project in the package Explorer and select “Export…” Under “Java”, select “JAR file”

3. You’ll be presented with a display in which you can select the files you ant to include in the JAR. In the “Select the resources…” area, select your Pie project. You probably want to check “Export generated class files..” and, optionally, “Export Java source files…”.

   In the “JAR file:” area, designate the name and location you want for the JAR file.

   Click on Next.

4. On the next screen, select “Save the description…” and choose a location. This will allow you to quickly rebuild the JAR if you alter make changes to the code in your project.

   Click Next.

5. Select “Generate the manifest file”. In projects like this one, where we have a single class that provides a main() function, we ca indicate that we want the Jar file to be “runnable”, meaning that it will use that class by default (e.g., if someone double-clicks on the Jar file in Windows). In the “Main class:” area select the PieSlicer class.

   Click FInish.

6. Check and you should find that a new jar file has been created.

7. Exit Eclipse,

8. Try transferring the newly created Jar file to another machine. Run it by double-clicking on it (if you are in Windows or a similar operating system) or via the command line with the command

   java -jar jarFileName
   

   You should see the now-familiar pie display pop up shortly.

• Compiling C++ in Eclipse (from CS252)
• Debugging C++ in Eclipse (from CS252)
• Supplying command-line parameters (video) when running programs in Eclipse