The original idea behind the Java Workshop was to introduce some of the practicalities faced when developing software using the Java Platform. As such, the original book focused on developing software using the Java Platform and not so much on the tools or the practical side of things. In revising the text, I decided to shift the focus somewhat to a new direction, the tools that a Java Developer should have in his / her toolbox.

It has often been said that the right tools for the job can make the job a lot easier. This is even more so when one considers the practice of developing software. When one uses the right tools, suddenly the task at hand becomes easier and quicker to accomplish creating a marked improvement in productivity. This book therefore focuses on the practical aspects of developing in Java specifically looking at common tasks and at the tools that make accomplishing these tasks easier and faster.

This is not a book that teaches Java. Instead it is a book that showcases typical tools found in a Java developer's toolbox. If you are looking for a book that teaches Java you should look elsewhere and once you've found such a book, you should couple it with this one, I guarantee the result will be worth it.

The idea behind this is far from original. Credit must be given to Bruce Eckel's Thinking in Java, which is freely available on the web and also available in printed format. While I used a similar concept, the Java Workshop differs fundamentally in that it may be redistributed and modified, much like open source software. For those that are a little finicky about details, the license is available here: License.

This book is for anyone interested in Java. Whether that interest is purely in an academic sense or truly a passion for the language, I hope that everyone can gain something from this book.

The target audience is specifically students who are learning Java for the first time. I remember when I first learnt Java, many of the trivialities were far from trivial and even the simple task of setting an environment variable was no small feat. I hope that if anything, this book will help students to accomplish these and many more trivial tasks and that they will not seem like small miracles.

The goal of this book is to introduce students to the practicalities of the Java language and provide them with enough references to pursue the topic further. In this regard, each topic is presented in a simplistic manner and a topic does not cover all there is, especially those topics that are extremely broad like XML. Rather a brief introduction is given and then a list of suitable references for further information.

It is recommended that you download the zip distribution archive. Windows XP has a native built-in Zip tool that allows you to extract zip archives. Other versions can use the Jar tool bundled with the JDK to extract the contents of the archive. Tools like Winzip and ZipGenius can extract the zip archive as well as the tarball.

Most Linux and Unix distributions have the tar utility so it is recommended that you download the tarball. If you do not have tar you may have unzip in which case it is advisable to get the zip archive. If you do not have any of these utilities you can use the Jar tool bundled with the JDK to extract the contents of the zip archive.

The JDK should be installed and setup by default. For information on upgrading go to Sun's Website and browse through the Solaris documentation.

Most newer versions of MacOS have the JDK installed and setup by default. For information on upgrading check out the MacOS documentation.

We will now test our installation by compiling and running a simple Java Program.

1. To run the program, type:

   java HelloWorld

   you should get the following output:

   Hello World!

1. Exception in thread "main" java.lang.NoSuchMethodError: main

   You must define a main method as: public static void main(String[] args) {...}

2. HelloWorld.java:3: illegal character: \8220 System.out.println(öHelloWorld!ö);

   Do not type your code in a word processor application that uses smart quotes!!

3. HelloWorld.class Exception in thread "main" java.lang.NoClassDefFoundError: HelloWorld/class

   The correct way to call a program is java HelloWorld without the ".java" or ".class"

The Java API is an Application Programmer Interface that describes in great detail the core Java Foundation Classes that make up the Java Platform. It highlights which packages make up the Platform, which classes belong to which packages and what methods and fields are available in each class. It is an invaluable tool to any Java Programmer.

Sun Microsystems's Java page can be accessed via the Internet at http://java.sun.com and it provides a download page where you can download all of the Java Technology that you want. It includes documentation: API's, Tutorials, Short Courses and White Papers. It often has industry news and updates and is also an invaluable resource to any Java programmer.

1. The JDK is available for which platforms?

   1. Windows
   2. Linux
   3. MacOS
   4. Sun Solaris
   5. All of the above

2. The JDK contains:

   1. Tools to develop software for the Java Platform
   2. A Java Runtime Environment
   3. The core Java API
   4. The Java Source Code
   5. All of the above

3. Installing the JDK requires:

   1. Extracting the JDK archive.
   2. Depends on the platform.
   3. Running the installation binary.
   4. Setting the path and classpath variables.
   5. 1 and 4.

4. The Java API:

   1. Explains which packages form the core of Java Programming Language
   2. Which classes are located in which package.
   3. Which methods a class contains.
   4. The fields that the class contains.
   5. All of the above.

5. Sun's java page:

   1. Contains the Java Tutorial.
   2. Contains all the Java Software.
   3. Is not worth visiting.
   4. 1 and 2.
   5. 2 and 3.

1. Install the JDK on your own computer.
2. Compile and Run the Hello World program.
3. Browse through the Java API.
4. Browse the Java page at Sun Microsystems's site: java.sun.com
5. Download or browse the Java Tutorial at: http://java.sun.com/docs/books/tutorial/index.html

1. Go read through the Java Tutorial at Sun's Java page and then try the following programs:
   1. Change the Hello World program so that it prints out your name.
   2. Write a program to display the first twenty powers of two.
   3. Write a program that generates a temperature conversion chart between Fahrenheit and Celsius.
   4. Write a program to display the first twenty Fibonacci numbers.
   5. Write a program that reads a number and displays it's square root.

1. Extract the eclipse archive to the C:\ drive using a program like Winzip or ZipGenius. You should end up with a folder in the C: drive named eclipse.

   

2. The eclipse program is in the eclipse folder and is a file named eclipse.exe. You can double click this file to run the program. You might want to create a shortcut to this file on your desktop or in your start menu.

   

1. Copy the Eclipse SDK archive to the /usr/local directory.

   cp eclipse-SDK-3.0-linux-gtk.zip /usr/local/

2. Change into the /usr/local directory and extract the archive.

   cd /usr/local/ unzip eclipse-SDK-3.0-linux-gtk.zip

3. Edit the file named java.sh in the /etc/profile.d directory and add the following to it.

   If you installed java according to chapter 1 you should have a file named java.sh in the /etc/profile.d directory. If not, now would be an opportune time to create it. export ECLIPSE_HOME=/usr/local/eclipse

4. Now add ECLIPSE_HOME to the PATH variable, save the file and exit your editor.

   PATH=${PATH}:${ECLIPSE_HOME}

   Log out and then log in again for the changes to take effect.

5. Run Eclipse: in a terminal type

   eclipse

6. In the dialog that asks you to select a workspace click the OK button. After eclipse has started, you will get a welcome screen.

1. Start eclipse with the command:

   eclipse

2. Select a workspace from the dialog and ensure to check the box that makes it the default workspace.

3. In the welcome screen, click on the "Workbench" icon.

   

4. From the File menu, select New and then Project.

   File > New > Project

5. In the New Project Dialog, click Java Project and then click the Next button.

   

6. In the New Java Project Dialog enter Hello World as the Project name and click the Finish button.

   

7. A dialog will pop up asking you to confirm the switch to the Java Perspective. Check the checkbox that reads Remember my decision and then click the Yes button.

   

8. In the Java Perspective, in the left side of the screen is the Package Explorer. In it you will see the Project named Hello World. Make Sure it is selected.

   

1. Select File from the menu and click New. Select Class.

   File > New > Class

2. In the New Java Class dialog enter HelloWorld as the name of the class, ensure that the public static void main(String[] args) checkbox is selected and then click the Finish button.

   

3. You'll notice in the source code editor that the class has already been created for you.

   

1. In the main method, type

   System.

   You'll notice a popup, prompting you to select a member of the System class. Select the out member.

2. Append the following to the line:

   .println("Hello World!")

3. You'll notice a red squiggly line under the closing bracket. This indicates that there is an error in your code. Add a semi colon (;) and it will disappear.

   

1. Select Save from the File menu to save the changes to the source code. You'll notice that Eclipse compiles source code automatically, every time that you save it.

   File > Save

1. Right Click on the HelloWorld.java file in the Package Explorer and select Run followed by Java Application from the pop up menu.

   Run > Java Application

2. You'll notice the output in the console.

   

We will now change a few of the default preferences.

1. Select Preferences from the Window menu.

   Window > Preferences

2. Click the arrow next to Workbench to expand the sub categories and select Colors and Fonts. In the right pane expand Java and then Java Editor Text Font. Click the Change button, and change the font according to your preferences.

   

3. In the left pane, expand the Java category and then the Code Style sub category. Select Code Templates. In the right pane select Comments and then Types. Click the Edit button and change the comment to your preferences.

   

4. Now select Code and then the New Java files sub category. Click the Edit button and change the comment according to your preferences.

   

5. In the left pane select Editor and select the Show line numbers check box.

   

6. Select the Syntax tab in the right pane and change the color of the keywords from mauve to blue. Click the Apply button.

   

7. Click the Ok button. You'll notice that the changes have taken effect in the source code editor.

   

We will now create a project outside of eclipse and then import it into eclipse.

1. In your home directory, create some directories:

   mkdir ~/test mkdir ~/test/src mkdir ~/test/classes

2. In Eclipse, create a new project by selecting New from the File menu and then select Project.

   File > New > Project

3. In the dialog, ensure that Java Project is selected and click the Next button.

4. In the next dialog, use Test as the project name. Then click the radio button that reads Create project at external location. Click the browse button and select the test directory in your home directory. Be sure to click the Next button.

   

5. In the source folders list, select Test and click the remove button. Click the Add Folder button and select the src directory. Click the OK button.

   

6. Click the browse button to change the Default output folder and select the classes directory. Click the Ok button.

   

7. The resulting changes should be as follows:

   

8. Click the Finish button.

You'll notice the Test project in the Package Explorer. We will define a package for our project.

1. In the package explorer expand the Test project.

2. Right click on the src folder in the package explorer and select New and then Package. Add test as the package name and click the Finish button.

   

3. You will now see the empty package in the Package Explorer.

We will create a simple class in the package we have just created..

1. Right click on the Test package. Create a new class named Cat by selecting New and then Class from the pop up menu.

   

2. Add two variables, one named age of type int and one named name of type String.

   

3. Add a simple constructor to initialize the variables.

   

Now we will use eclipse to generate getter and setter methods for our class.

1. Select Generate Getters and Setters from the Source menu.

   Source > Generate Getters and Setters

2. In the dialog click the Select All button followed by the Ok button.

   

3. You'll notice that the get and set methods were created.

   

4. Don't forget to save the file.

We would like to change the name of the package from test and have all changes reflected. First we will create a main program that will use our class.

1. Create a new package named com.acme.test.main

2. Create a program called Main in the new package.

   

3. Add the following code to the main method.

   Cat kitty = new Cat()

4. You will again notice some squiggly red lines. In the gutter next to the line numbers you will see a hint icon. Click on it.

   

5. In the pop up hint you will be prompted to import the Cat class. Do so, by clicking on the suggestion. You will notice that an import statement has been added to your code, namely: import test.Cat. Save the class.

   

6. Right click on the test package in the Package Explorer and select refactor from the menu. Select Rename from the sub menu.

   Refactor > Rename

7. Rename the package to com.acme.test.pets .

   

8. If you look at the main class, you'll notice that the import statement has changed to match the new package name, ie: import com.acme.test.pets.Cat!

   

1. Eclipse is written in which language?

   1. Pascal
   2. C
   3. C++
   4. Java
   5. Delphi

2. Eclipse is:

   1. Proprietary Software
   2. Commercial Software
   3. Open Source Software
   4. Shareware
   5. Freeware

3. Which is not a feature of Eclipse

   1. Eclipse allows easy refactoring of code.
   2. Eclipse is available for many platforms.
   3. Eclipse has Apache Ant integrated into it.
   4. Eclipse requires you to compile source code after it is saved.
   5. Eclipse has JUnit integrated into it.

4. Eclipse allows you to:

   1. Generate new classes and interfaces quickly and easily.
   2. Use third-party plug-ins.
   3. Generate getters and setters.
   4. Refactor code.
   5. All of the above.

5. Eclipse is available for:

   1. Windows
   2. Linux
   3. Sun Solaris
   4. 1 and 2.
   5. 2 and 3.

1. Install the Eclipse on your own computer.
2. Create the Hello World program described in this chapter.
3. Import your existing projects into Eclipse.
4. Configure the Preferences of Eclipse according to your taste.
5. Install the plug-in as described in this chapter.

1. Complete the following programs using Eclipse:
   1. A program that calculates how much is left of a bank loan. Input parameters are initial loan amount, interest rate, payment per month and current month.
   2. A program to calculate the average of a list of numbers.
   3. A program that calculates a student's grade from grades, each counting an equal percentage.

One of the many concerns that programmers face today is trying to ensure that their source code does not conflict with the source code of other programmers. A typical example is the case when two programmers define two distinct classes that have the same name. Suppose you decide to write a List class that keeps a sorted list of objects. This would inherently conflict with the List class in the Java API that is used to display a list of items in a Graphical User Interface. Java has a simple solution to this problem that is known as namespace management. Each programmer defines their own namespace and place their code within that namespace, thus two classes that have the exact same name are now distinguishable since they occur in different name spaces. Namespaces are called packages in Java.

Another important reason for using packages is that it provides programmers with greater control over their source code. It is typical to have a few thousand source files in medium to large scale applications, and trying to maintain them would be difficult at best, if not impossible. However, separating these source files into packages makes it much easier to manage the source code. What usually occurs is that related classes are grouped into a single package, for example, all the user interface classes of an application will be grouped into a package.

Access protection is another benefit of using packages. Suppose a group of different applications utilize the same set of source code, it would make sense to separate this source code and maintain it as a separate library that each application uses. In such a library, there is a public interface and a private interface. The public interface is those classes and methods that are accessible to the application using the library, while the private interface is not accessible to the application. Using a package makes it easier to define which classes form part of the public interface and which are part of the private interface. This makes it easy to control access to certain code sections.

Some of the benefits of using packages are:

It shows that the classes and interfaces in the package are related.

Often a group of classes and interfaces are related according to functionality so naturally they should be grouped into a package. An excellent example is the java.io package which groups a set of classes that all perform input and output functions.

You know where to find the classes you want if they're in a specific package.

If you are looking for a specific class and you know what functionality it provides you will naturally be able to find it in the right package. If you are looking for an InputStreamReader you will find it in the input and output package, ie: java.io

The names of your classes and interfaces won't be in conflict with those of other programmers.

If you decide to implement your own String class and you place it in a package it will be distinguishable from the java.lang.String class that comes with the Java API.

You can restrict the access to your classes.

When you only want your code or program to access certain code, for example in a library, then using packages makes access control to source code much easier.

Creating a Java Package is relatively simple but may seem a bit confusing for people who have not done it before. There are two fundamental requirements for a package to exist:

• The package must contain one or more classes or interfaces. This implies that a package cannot be empty.
• The classes or interfaces that are in the package must have their source files in the same directory structure as the name of the package.

Once you have created your package you may want to use it in your program or you may wish to use another programmer's package or the packages in the Java API. There are three ways of using the resources in a package; inline package member declarations, importing only the package member that you want and importing the entire package.

1. Namespaces are used to:

   1. Control access to classes.
   2. Resolve naming conflicts among programmers.
   3. Bundle a set of classes together.

2. Which is not a benefit of using packages?

   1. Finding the classes you want is difficult.
   2. Access protection.
   3. Separation of source and class files.

3. To create a package named "za.co.nephila.maculata" you would use which statement?

   1. package maculata
   2. package nephila.maculata
   3. package za.co.nephila.maculata

4. To import the ChatServer member of the Maculata package (za.co.nephila.maculata) you would use:

   1. import maculata.*;
   2. import za.co.nepihla.maculata.*;
   3. import za.co.nephila.maculata.ChatServer;

5. The classes of the Maculata package (za.co.nephila.maculata) will be in which directory?

   1. /Maculata/classes
   2. /Maculata/classes/za/co/nephila/maculata
   3. /Maculata/src/za/co/nephila/maculata

1. Take a look at the Java API and see how the packages are structured.

1. Complete the following:
   1. Create a package named org.shapes.
   2. Create some classes in the package representing some common geometric shapes like Square, Triangle, Circle and so on.
   3. Finally compile the package as discussed in this chapter.

There are a number of reasons for including comments in source coe, even though many newer software development methodologies refrain from their use, comments do have their place in source code. Some of the reasons for using comments are:

• Often comments are added at the start of each source file to give a description of what source the file contains and copyright information.
• The fields and methods of a class are often given brief comments that describe their purpose and what they do.
• Complex code is often commented heavily to make it clearer and easier to understand.

The goal in commenting code is to make it possible for the reader to understand what the code does and how it achieves that. There are generally two schools of thought on this, the first says that the more comments the better, however the other school of thought believes that more comments just clutter the code and make it difficult to read.

Commenting code is therefore a fine balance, you should only provide comments where absolutely necessary and keep them brief. If code is too complex to understand you should consider revising the code to make it clearer or simpler, unless it is impossible to do so or you have very good reasons not to do so.

A Javadoc comment precedes any class, interface, method or field declaration and is similar to a multi-line comment except that it starts with a forward slash followed by two atserisks (/**). The basic format is a description followed by any number of predefined tags. The entrie comment is indented to align with the source code directly beneath it and it may contain any valid HTML. Generally paragraphs should be separated or designated with the <p> tag. As an example consider:

We will now discuss the descriptions of a Javadoc comment first before looking at the different tags and their uses.

The description should give a concise summary of the item being commented. It should be written in simple and clear English using correct spelling and grammar. Punctuation is required. There are some important style guidelines to bear in mind:

The Javadoc tags are used to provide important or essential meta information about the code. Consider the @author tag in the class comment for the example given above, it gives important information as to who the author of the code is. Each tag has a specific format which we will now look at.