The presentations at the first Java Day in New York City were crucial to getting my understanding of Java off the ground, especially those of Bill Joy and Frank Greco.

The eventtutor applet, flying lines applet and Mondrian applets are taken in spirit if not in code from Dave Mark and Cartwright Reed’s Macintosh Programming Primer.

Finally I’d like to thank Olivia Whiteman, Dave Fisco, Tim Arnold and all the other Java Invaders for putting together forums in which I could learn more Java.

People are excited about Java because of what it lets them do. Java was the first way to include inline sound and animation in a web page. Java also lets users interact with a web page. Instead of just reading it and perhaps filling out a form, users can now play games, calculate spreadsheets, chat in realtime, get continuously updated data and much, much more.

Here are just a few of the many things Java can do for a web page:

• Inline sounds that play in realtime whenever a user loads a page
• Music that plays in the background on a page
• Cartoon style animations
• Realtime video
• Multiplayer interactive games

However Java is more than just a web browser with special features. All of these features can be integrated into browsers in other ways. Although HotJava was the first browser to include inline sound and animation, Microsoft’s Internet Explorer 2.0 and Netscape Navigator 2.0 support these features in several different ways. What makes Java special?

Java is a programming language for distributed applications. It doesn’t just allow you to add new types of content to your pages like Netscape and Internet Explorer do. Rather it lets you add both the content and the code necessary to interact with that content. You no longer need to wait for the next release of a browser that supports your preferred image format or special game protocol. With Java you send browsers both the content and the program necessary to view this content at the same time!

Let’s think about what this means for a minute. Previously you had to wait for all the companies that make the web browsers your readers use to update their browsers before you could use a new content type. Then you had to hope that all your readers actually did update their browsers. Java compatibility is a feature that any browser can implement and by so doing implement every feature!

For instance let’s say you want to use EPS files on your Web site. Previously you had to wait until at least one web browser implemented EPS support. Now you don’t wait. Instead you can write your own code to view EPS files and send it to any client that requests your page at the same time they request the EPS file.

Or suppose you want people to be able to search your electronic card catalog. However the card catalog database exists on a mainframe system that doesn’t speak HTTP. Before Java you could hope that some browser implemented your proprietary card catalog protocol; (fat chance) or you could try to program some intermediate cgi-bin on a UNIX box that can speak HTTP and talk to the card catalog, not an easy task. With Java when a client wants to talk to your card catalog you can send them the code they need to do so. You don’t have to try to force things through an httpd server on port 80 that were never meant to go through it.

If that were all Java was, it would still be more interesting than a <marquee> or <frame> tag in some new browser beta. But there’s a lot more. Java is platform independent. A Java program can run equally well on any architecture that has a Java enabled browser. With the release of Netscape Navigator 2.0 that includes Windows 95, Windows NT, the MacOS, Sun Solaris, Sun OS 4.1.3, SGI IRIX, OSF/1, HP-UX with more to come. But wait. There’s more!

Java isn’t just for web sites. Java is a programming language that lets you do almost anything you can do with a traditional programming langauge like Fortran or C++. However Java has learned from the mistakes of its predecessors. It is considerably cleaner and easier to use than those languages.

As a language Java is

Simple

Java has the bare bones functionality needed to implement its rich feature set. It does not add lots of syntactic sugar or unnecessary features.

Object-Oriented

Almost everything in Java is either a class, a method or an object. Only the most basic primitive operations and data types (int, for, while, etc.) are at a sub-object level.

Platform Independent

Java programs are compiled to a byte code format that can be read and run by interpreters on many platforms including Windows 95, Windows NT, and Solaris 2.3 and later.

Safe

Java code can be executed in an environment that prohibits it from introducing viruses, deleting or modifying files, or otherwise performing data destroying and computer crashing operations.

High Performance

Java can be compiled on the fly with a Just-In-Time compiler (JIT) to code that rivals C++ in speed.

Multi-Threaded

Java is inherently multi-threaded. A single Java program can have many different things processing independently and continuously.

Borland is also working a Java development environment to be released in the first half of 1996. Various third-party efforts are under way to port Java to other platforms including the Amiga, Windows 3.1, OS/2 and others.

The basic Java environment consists of a web browser that can play Java applets, a Java compiler to turn to Java source code into byte code, and a Java interpreter to run Java programs. These are the three key components of a Java environment. You’ll also need a text editor like Brief or BBEdit. Other tools like a debugger, a visual development environment, documentation and a class browser are also nice but aren’t absolutely necessary.

Note that it isn’t necessary to get all three of these from the same source. For instance Netscape is committed to providing a Java-enabled web browser. However it will only provide a Java compiler with the next version of its server products.

Sun has made the Java Developers Kit available for its supported platforms. It includes an applet viewer that will let you view and test your applets. The JDK also includes the javac compiler, the java interpreter, the javaprof profiler, the javah header file generator (for integrating C into your Java code), the Java debugger and limited documentation. However most of the documentation for the API and the class library is on Sun’s web site.

You can ftp the programs from the following sites:

* USA
o _ftp://ftp.javasoft.com/pub/
o _ftp://www.blackdown.org/pub/Java/pub/
o _ftp://ftp.science.wayne.edu/pub/java/
o _ftp://metalab.unc.edu/pub/languages/
o _ftp://java.dnx.com/pub/
* Germany: _ftp://sunsite.informatik.rwth-aachen.de/pub/mirror/java.sun.com/JDK-beta-win32-x86.exe
* Korea: _ftp://ftp.kaist.ac.kr/pub/java/e
* China: _ftp://math01.math.ac.cn/pub/sunsite
* Japan: _ftp://ftp.glocom.ac.jp/mirror/java.sun.com/
* Sweden: _ftp://ftp.luth.se/pub/infosystems/www/hotjava/pub/
* Singapore: _ftp://ftp.iss.nus.sg/pub/java/
* United Kingdom: _ftp://sunsite.doc.ic.ac.uk/packages/java/

Macintosh Installation Instructions

The file you get will be a self-extracting archive called something like JDK-1_0_2-MacOS.sea.bin. If you use Fetch or Anarchie to download it will be automatically converted into the self-extracting JDK-1_0_2-MacOS.sea. Double-click it to extract it and the double-click the resulting installer JDK-1_0_2-MacOS. It will prompt you for a location to put it on your hard disk. Put it wherever is convenient.

It may be helpful to make aliases of the Applet Viewer, the Java Compiler and the Java Runner and put them on your desktop for ease of dragging and dropping later, especially if you have a large monitor.

You will need to add C:\java\bin directory to your PATH environment variable

In addition to the java files, the archive includes two common DLL’s:

• MSVCRT20.DLL
• MFC30.DLL

These two files will be installed in your java directory. If you do not already have copies of these two files on your system, (There’s a very good chance you do, probably in your system directory.) copy them into the C:\java\bin directory. If you do have these two files already, just delete these extra copies.

The Unix release is a compressed tar file. You will need about nine megabytes of disk space to uncompress and untar the JDK. Double that would be very helpful. You do this with the commands:

% uncompress JDK-1_0_2-solaris2-sparc.tar.Z
% tar xvf JDK-1_0_2-solaris2-sparc.tar

The exact file name may be a little different if you�re retrieving the release for a different platform such as Irix or if the version is different. You can untar it in your home directory, or, if you have root privileges, in some convenient place like /usr/local where all users can have access to the files. However root privileges are not necessary to install or run Java. Untarring the file creates all necessary directories and sub-directories. The exact path is unimportant, but for simplicity’s sake this book assumes it�s installed it in /usr/local. If a sysop already installed it, this is probably where it lives. (Under Solaris it’s also possible the sysop put it into /opt.) If this is the case the files live in /usr/local/java. If you unpacked it somewhere else, just replace /usr/local by the full path to the java directory in what follows. If you installed it in your home directory, you can use ~/java and ~/hotjava instead of a full path.

You now need to add /usr/local/java/bin directory to your PATH environment variable. You use one of the following commands depending on your shell.

csh, tcsh:
	% set path=($PATH /usr/local/java/bin)
sh:
	% PATH=($PATH /usr/local/java/bin); export $PATH

You should also add these lines to the end of your .profile and .cshrc files so you won’t have to do this every time you login. Now you’re ready to run some applets.

Start the Applet Viewer by doing the following:

1. Open a command line prompt, and cd to one of the directories in /usr/local/java/demo, for example

   % cd /usr/local/java/demo/TicTacToe
   

2. Run the appletviewer on the html file:

   % appletviewer example1.html 

3. Play Tic-Tac-Toe! The algorithm was deliberately broken so it is possible to win.

Macintosh Instructions

1. Start the Applet Viewer by double-clicking it.
2. Select Open… from the File menu and navigate into the java folder, then the Sample Applets folder, then the TicTacToe folder.
3. Select the file example1.html and click on the Open button. Alternately you can drag and drop this file onto the Applet Viewer.
4. Play Tic-Tac-Toe! The algorithm was deliberately broken so it is possible to win.

Windows Instructions

Start the Applet Viewer by doing the following:

1. Open a DOS window, and cd to one of the directories in C:\JAVA\DEMO, for example

   C:< cd C:\JAVA\DEMO\TicTacToe
   

2. Run the appletviewer on the html file:

   C:< appletviewer example1.htm 

3. Play Tic-Tac-Toe! The algorithm was deliberately broken so it is possible to win.

Hot Tip: Getting Rid of that Annoying License Dialog Box

Do you know the annoying dialog box I’m talking about? I bet you do. It’s the one that comes up every time you launch the applet viewer to make you agree to Sun’s license. Do you want to get rid of it? If so make a directory called .hotjava in your java/bin directory. You won’t see it again.

The following is the Hello World Application as written in Java. Type it into a text file or copy it out of your web browser, and save it as a file named HelloWorld.java.

class HelloWorld {

  public static void main (String args[]) {

    System.out.println("Hello World!");

  }

}

To compile this program make sure you’re in the same directory HelloWorld.java is in and type javac HelloWorld.java at the command prompt. Hello World is very close to the simplest program imaginable. Although it doesn’t teach very much from a programming standpoint, it gives you a chance to learn the mechanics of writing and compiling code. If you’re like me your first effort won’t compile, especially if you typed it in from scratch rather than copying and pasting. Here are a few common mistakes:

For now the initial class statement may be thought of as defining the program name, in this case HelloWorld. The compiler actually got the name for the class file from the class HelloWorld statement in the source code, not from the name of the source code file. If there is more than one class in a file, then the Java compiler will store each one in a separate .class file. For reasons we’ll see later it’s advisable to give the source code file the same name as the main class in the file plus the .java extension.

The initial class statement is actually quite a bit more than that since this “program” can be called not just from the command line but also by other parts of the same or different programs. We’ll see more in the section on classes and methods below.

The HelloWorld class contains one method, the main method. As in C the main method is where an application begins executing. The method is declared public meaning that the method can be called from anywhere. It is declared static meaning that all instances of this class share this one method. (If that last sentence was about as intelligible as Linear B, don’t worry. We’ll come back to it later.) It is declared void which means, as in C, that this method does not return a value. Finally we pass any command line arguments to the method in an array of Strings called args. In this simple program there aren’t any command line arguments though.

Finally when the main method is called it does exactly one thing: print “Hello World” to the standard output, generally a terminal monitor or console window of some sort. This is accomplished by the System.out.println method. To be more precise this is accomplished by calling the println() method of the static out field belonging to the System class; but for now we’ll just treat this as one method.

One final note: unlike the printf function in C the System.out.println method does append a newline at the end of its output. There’s no need to include a \n at the end of each string to break a line.

Exercises

1. What happens if you change the name of the source code file, e.g. HelloEarth.java instead of HelloWorld.java?
2. What happens if you keep the name of the source code file the same (HelloWorld.java) but change the class’s name, e.g. class HelloEarth?

Blocks are important both syntactically and logically. Without the braces the code wouldn’t compile. The compiler would have trouble figuring out where one method or class ended and the next one began. Similarly it would be very difficult for someone else reading your code to understand what was going on. For that matter it would be very difficult for you, yourself to understand what was going on. The braces are used to group related statements together. In the broadest sense everything between matching braces is executed as one statement (though depending not necessarily everything inside the braces is executed every time).

Blocks can be hierarchical. One block can contain one or more subsidiary blocks. In this case we have one outer block that defines the HelloWorld class. Within the HelloWorld block we have a method block called “main”.

In this tutorial we help to identify different blocks with indentation. Every time we enter a new block we indent our source code by two spaces. When we leave a block we deindent by two spaces. This is a common convention in many programming languages. However it is not part of the language. The code would produce identical output if we didn’t indent it. In fact I’m sure you’ll find a few examples here where I haven’t followed convention precisely. Indentation makes the code easier to read and understand, but it does not change its meaning.