Separating your programs from mine

In Chapter 2, you download this book’s examples from my website. Then you create an Eclipse workspace and import the book’s examples into your workspace.

You can create your own projects in the same workspace. But if you want to separate your code from mine, you can create a second workspace. Here are two ways to create a new workspace:

• When you launch Eclipse, type a new folder name in the Workspace field of Eclipse’s Workspace Launcher dialog box.

  If the folder doesn’t already exist, Eclipse creates the folder. If the folder already exists, Eclipse’s Package Explorer lists any projects that the folder contains.

• On the Eclipse workbench’s main menu, choose File ⇒ Switch Workspace. (See Figure 3-6.)

  When you choose File ⇒ Switch Workspace, Eclipse offers you a few of your previously opened workspace folders. If your choice of folder isn’t in the list, select the Other option. In response, Eclipse reopens its Workspace Launcher dialog box.

Writing and running your program

Here’s how you create a new Java project:

1. Launch Eclipse.

2. From Eclipse’s menu bar, choose File ⇒ New ⇒ Java Project.

   A New Java Project dialog box appears.

3. In the New Java Project dialog box, type a name for your project and then click Finish.

   In Figure 3-7, I type the name MyFirstProject.

   If you click Next instead of Finish, you see some other options that you don’t need right now. To avoid any confusion, just click Finish.

   Clicking Finish brings you back to Eclipse’s workbench, with MyFirstProject in the Package Explorer, as shown in Figure 3-8.

   The next step is to create a new Java source code file.

4. Select your newly created project in the Package Explorer.

   To create Figure 3-8, I selected MyFirstProject instead of SomeOtherProject.

5. In Eclipse’s main menu, choose File ⇒ New ⇒ Class.

   Eclipse’s New Java Class dialog box appears. (See Figure 3-9.)

   Java programmers normally divide their code into one or more packages. A typical package has a name like java.util or org.allyourcode.images. In Figure 3-9, Eclipse is warning me that I’m not naming a package to contain my project’s code. So the code goes into a nondescript thing called Java’s default package. Java’s default package is a package with no name — a catchall location for code that isn’t otherwise packaged. Packages are great for managing big programming projects, but this book contains no big programming projects. So, in this example (and in all of this book’s examples), I choose to ignore the warning. For more info about Java packages, see Chapter 18.

   Like every other windowed environment, Eclipse provides many ways to accomplish the same task. Instead of choosing File ⇒ New ⇒ Class, you can right-click MyFirstProject in the Package Explorer in Windows (or control-click MyFirstProject in the Package Explorer on a Mac). From the resulting context menu, choose New ⇒ Class. You can also start by pressing Alt+Shift+N in Windows (or Option+⌘  +N on a Mac). The choice of clicks and keystrokes is up to you.

6. In the New Java Class dialog box’s Name field, type the name of your new class.

   In this example, I use the name MyFirstJavaClass, with no blank spaces between any of the words in the name. (Refer to Figure 3-9.)

   The name in the New Java Class dialog box cannot have blank spaces. And the only allowable punctuation symbol is the underscore character (_). You can name your class MyFirstJavaClass or My_First_Java_Class, but you can’t name it My First Java Class or JavaClass,MyFirst.

7. Put a check mark in the public static void main(String[] args) check box.

   Your check mark tells Eclipse to create some boilerplate Java code.

8. Accept the defaults for everything else in the New Java Class dialog box. (In other words, click Finish.)

   You can even ignore the “Default Package Is Discouraged” warning near the top of the dialog box.

   Clicking Finish brings you back to Eclipse’s workbench. Now MyFirstProject contains a file named MyFirstJavaClass.java. For your convenience, the MyFirstJavaClass.java file already has some code in it. Eclipse’s editor displays the Java code. (See Figure 3-10.)

9. Replace an existing line of code in your new Java program.

   Type a line of code in Eclipse’s Editor. Replace the line

   // TODO Auto-generated method stub

   with the line

   System.out.println("Chocolate, royalties, sleep");

   Copy the new line of code exactly as you see it in Listing 3-1.

   • Spell each word exactly the way I spell it in Listing 3-1.
   • Capitalize each word exactly the way I do in Listing 3-1.
   • Include all the punctuation symbols — the dots, the quotation marks, the semicolon — everything.

   • Distinguish between the lowercase letter l and the digit 1. The word println tells the computer to print a whole line. Each character in the word println is a lowercase letter. The word contains no digits.

   Java is case-sensitive, which means that system.out.printLn isn’t the same as System.out.println. If yOu tyPe system.out.printLn, your progrAm won’t worK. Be sUre to cAPItalize your codE eXactLy as it is in LiSTIng 3-1.

   If you copy and paste code from an ebook, check to make sure that the quotation marks in the code are straight quotation marks (""), not curly quotation marks (“ ”). In a Java program, straight quotation marks are good; curly quotation marks are troublesome.

   If you typed everything correctly, you see the stuff in Figure 3-11.

   If you don’t type the code exactly as it’s shown in Listing 3-1, you may see jagged red underlines, tiny rectangles with X-like markings inside them, or other red marks in the editor. (See Figure 3-12.)

   The red marks in Eclipse’s editor refer to compile-time errors in your Java code. A compile-time error (also known as a compiler error) is an error that prevents the computer from translating your code. (See the talk about code translation in Chapter 1.)

   The error marker in Figure 3-12 appears on line 5 of the Java program. Line numbers appear in the editor’s left margin. To make Eclipse’s editor display line numbers, choose Window ⇒ Preferences (in Windows) or Eclipse ⇒ Preferences (on a Mac). Then choose General ⇒ Editors ⇒ Text Editors. Finally, put a check mark in the Show Line Numbers check box.

   To fix compile-time errors, you must become a dedicated detective. You join an elite squad known as Law & Order: Java Programming Unit. You seldom find easy answers. Instead, you comb the evidence slowly and carefully for clues. You compare everything you see in the editor, character by character, with my code in Listing 3-1. You don’t miss a single detail, including spelling, punctuation, and uppercase-versus-lowercase.

   Eclipse has a few nice features to help you find the source of a compile-time error. For example, you can hover the mouse pointer over the jagged red underline. When you do, you see a brief explanation of the error along with some suggestions for repairing the error — some quick fixes. (See Figure 3-13.)

   In Figure 3-13, a pop-up message tells you that Java doesn’t know what the word system means — that is, system cannot be resolved. Near the bottom of the figure, one of the quick fix options is to change system to System.

   When you click that Change To ’System’ (java.lang) option, Eclipse’s editor replaces system with System. The editor’s error markers disappear, and you go from the incorrect code in Figure 3-12 to the correct code back in Figure 3-11.

10. Make any changes or corrections to the code in Eclipse’s editor.

    When at last you see no jagged underlines or blotches in the editor, you’re ready to try running the program.

11. Select MyFirstJavaClass either by clicking inside the editor or by clicking the MyFirstProject branch in the Package Explorer.

12. From Eclipse’s main menu, choose Run ⇒ Run As ⇒ Java Application.

    That does the trick. Your new Java program runs in Eclipse’s Console view. If you’re running the code in Listing 3-1, you see the Chocolate, royalties, sleep message in Figure 3-14. It’s like being in heaven!

LISTING 3-1 A Program to Display the Things I Like

public class MyFirstJavaClass {

public static void main(String[] args) {
System.out.println("Chocolate, royalties, sleep");

}

}

Understanding the big picture

Your tour of Eclipse begins with a big Burd’s-eye view.

• Workbench: The Eclipse Desktop. (Refer to Figure 3-3.) The workbench is the environment in which you develop code.
• Area: A section of the workbench. The workbench in Figure 3-3 contains five areas. To illustrate the point, I’ve drawn borders around each of the areas. (See Figure 3-15.)
• Window: A copy of the Eclipse workbench. With Eclipse, you can have several copies of the workbench open at once. Each copy appears in its own window.
• Action: A choice that’s offered to you — typically, when you click something. For example, when you choose File ⇒ New on Eclipse’s main menu bar, you see a list of new things that you can create. The list usually includes Project, Folder, File, and Other, but it may also include things like Package, Class, and Interface. Each of these things (each item on the menu) is called an action.

Views, editors, and other stuff

The next bunch of terms deals with things called views, editors, and tabs.

You may have difficulty understanding the difference between views and editors. (A view is like an editor, which is like a view, or something like that.) If views and editors seem the same to you and you’re not sure that you can tell which is which, don’t be upset. As an ordinary Eclipse user, the distinction between views and editors comes naturally as you gain experience using the workbench. You rarely have to decide whether the thing you’re using is a view or an editor.

If you ever have to decide what a view is as opposed to an editor, here’s what you need to know:

• View: A part of the Eclipse workbench that displays information for you to browse. In the simplest case, a view fills up an area in the workbench. For example, in Figure 3-15 the Package Explorer view fills up the leftmost area.

  Many views display information as lists or trees. For example, in Figure 3-10 the Package Explorer view contains a tree.

  You can use a view to make changes to things. For example, to delete the 03-01 project listed on the left side in Figure 3-15, right-click the 03-01 branch in the Package Explorer view. (On a Mac, control-click the 03-01 branch.) Then, on the resulting context menu, choose Delete.

  When you use a view to change something, the change takes place immediately. For example, when you choose Delete on the Package Explorer’s context menu, whatever item you’ve selected is deleted immediately. In a way, this behavior is nothing new. The same kind of thing happens when you recycle a file using Windows Explorer or trash a file using the Macintosh Finder.

• Editor: A part of the Eclipse workbench that displays information for you to modify. A typical editor displays information in the form of text. This text can be the contents of a file. For example, an editor in Figure 3-11 displays the contents of the MyFirstJavaClass.java file.

  When you use an editor to change something, the change doesn’t take place immediately. For example, look at the editor in Figure 3-11. This editor displays the contents of the MyFirstJavaClass.java file. You can type all kinds of things in the editor. Nothing happens to MyFirstJavaClass.java until you choose File ⇒ Save from Eclipse’s menu bar. Of course, this behavior is nothing new. The same kind of thing happens when you work in Microsoft Word or in any other word processing program.

  Like other authors, I occasionally become lazy and use the word view when I really mean view or editor. When you catch me doing this, just shake your head and move onward. When I’m being very careful, I use the official Eclipse terminology. I refer to views and editors as parts of the Eclipse workbench. Unfortunately, this “parts” terminology doesn’t stick in people’s minds very well.

An area of the Eclipse workbench might contain several overlapping views or overlapping editors. To bring one view or editor to the forefront, you click a tab. Most Eclipse users get along fine without giving this “several views” business a second thought (or even a first thought). But if you care about the terminology surrounding tabs and active views, here’s the scoop:

• Tab: Something that’s impossible to describe except by calling it a tab. That which we call a tab by any other name would move us as well from one view to another or from one editor to another. The important thing is, views can be stacked on top of one another. Eclipse displays stacked views as though they’re pages in a tabbed notebook. For example, Figure 3-14 displays one area of the Eclipse workbench. The area contains five views (the Problems view, the Javadoc view, the Declaration view, the Search view, and the Console view). Each view has its own tab.

  A bunch of stacked views is called a tab group. To bring a view in the stack to the forefront, you click that view’s tab.

  And, by the way, all this stuff about tabs and views holds true for tabs and editors. The only interesting thing is the way Eclipse uses the word editor. In Eclipse, each tabbed page of the editor area is an individual editor. For example, the Editor area in Figure 3-16 contains three editors (not three tabs belonging to a single editor).

• Active view or active editor: In a tab group, the view or editor that’s in front.

  In Figure 3-16, the MyFirstJavaClass.java editor is the active editor. The Mortgage.java and ThingsILike.java editors are inactive.

What’s inside a view or an editor?

The next several terms deal with individual views, individual editors, and individual areas.

• Toolbar: The bar of buttons (and other little things) at the top of a view. (See Figure 3-17.)
• Menu button: A downward-pointing arrow in the toolbar. When you click the Menu button, a drop-down list of actions appears. (See Figure 3-18.) Which actions you see in the list varies from one view to another.
• Close button: A button that gets rid of a particular view or editor. (See Figure 3-19.)
• Chevron: A double arrow indicating that other tabs should appear in a particular area (but that the area isn’t wide enough). The chevron in Figure 3-20 has a little number 2 beside it. The 2 tells you that, in addition to the two visible tabs, two tabs are invisible. Clicking the chevron brings up a hover tip containing the labels of all the tabs.
• Marker bar: The vertical ruler on the left edge of the editor area. Eclipse displays tiny alert icons, called markers, inside the marker bar. (For an example, refer to Figure 3-12.)

Returning to the big picture

The next two terms deal with Eclipse’s overall look and feel:

• Layout: An arrangement of certain views. The layout in Figure 3-3 has seven views, of which four are easily visible:

  • At the far left, you see the Package Explorer view.
  • On the far right, you have the Task List view and the Outline view.
  • Near the bottom, you get the Problems, Javadoc, Declaration, and Console views.

  Along with all these views, the layout contains a single editor area. Any and all open editors appear inside this editor area.

• Perspective: A very useful layout. If a particular layout is really useful, someone gives that layout a name. And if a layout has a name, you can use the layout whenever you want. For example, the workbench of Figure 3-3 displays Eclipse’s Java perspective. By default, the Java perspective contains six views in an arrangement very much like the arrangement shown in Figure 3-3.

  The Console view appears in Figure 3-3, but the Console view doesn’t always appear as part of the Java perspective. Normally, the Console view appears automatically when you run a text-based Java program. If you want to force the Console view to appear, choose Window ⇒ Show View ⇒ Other. In the resulting Show View dialog box, expand the General branch. Finally, within that General branch, double-click the Console item.

  Along with all these views, the Java perspective contains an editor area. (Sure, the editor area has several tabs, but the number of tabs has nothing to do with the Java perspective.)

  You can switch among perspectives by choosing Window ⇒ Open Perspective in Eclipse’s main menu bar. This book focuses almost exclusively on Eclipse’s Java perspective. But if you like poking around, visit some of the other perspectives to get a glimpse of Eclipse’s power and versatility.

Here are some things for you to try to help you understand the material in this chapter. If trying these things builds your confidence, that’s good. If trying these things makes you question what you’ve read, that’s good too. If trying these things makes you nervous, don’t be discouraged. You can find answers and other help at this book’s website (www.allmycode.com/BeginProg). You can also email me with your questions ([email protected]).