Java first became popular because of its capability to run on web pages. Using a plug-in, Microsoft Internet Explorer, Mozilla Firefox, and other browsers can download a Java program included on a web page and run it locally on the web user’s system.

These programs, which are called applets, run interactively on web pages—taking user input, responding to it, and presenting ever-changing content.

Applets can be used to create animation, charts, games, multimedia presentations, and other interactive effects.

Figure 1 shows an applet running in its own window using Java Web Start, a technology for launching software from web pages. This applet, Every Icon, is an interactive work of art implemented in Java by John F. Simon, Jr., an artist and programmer who has taught at the School of Visual Arts in Manhattan. It has been shown at the Whitney Biennial art exhibition and purchased by the Guggenheim Museum and the San Francisco Museum of Modern Art.

Figure 1. A Java applet that displays billions of black-and-white icons in sequence.

Applets are downloaded over the Web just like pages, graphics, and any other element of a website. On a web browser equipped to handle Java, the applet begins running when it finishes downloading.

Applets are written with the Java language, compiled into a form that can be run as a program, and placed on a web server.

The programs are run by the Java Plug-in, a browser enhancement offered by Sun Microsystems. If a user visits a page containing an applet with a browser that cannot run Java, a dialog box opens, asking whether the Java Plug-in should be downloaded and installed.

Applets have grown far less common on the Web, where a rival technology called Macromedia Flash has become the most popular means of presenting interactive content.

But the language has continued to rise in popularity because it can be used to develop a wide range of software supporting graphical user interfaces, networking, database connectivity, and other sophisticated functionality.

Java programs that don’t run within a web browser are called applications.

The Java language was developed at Sun Microsystems in 1990 as part of a project codenamed Green that was a research effort into consumer electronics. Sun was working on a programming language for smart appliances to talk to each other, so your refrigerator could tell your phone to call you when the milk’s gone bad.

To put its research into action, Green developed a prototype device called the Star 7, a handheld gadget resembling today’s PDA devices that could communicate with others of its own kind.

The original idea was to develop the Star 7 operating system in C++, the object-oriented programming language created by Bjarne Stroustrup. When Green project member James Gosling became fed up with how C++ was performing on the task, he barricaded himself in his office and wrote a new language to handle the Star 7 better.

The language was named Oak in honor of a tree Gosling could see out his office window. It was later renamed Java in honor of the lawyers who found out about another product called Oak (and didn’t want Sun to go out on a limb).

Because Java was designed for embedded electronic devices instead of state-of-the-art PCs, it had to be small, efficient, and easily portable to a wide range of hardware devices. It also had to be reliable. People have learned to live with occasional system crashes and lockups in a 30MB software application. However, there aren’t many people willing to debug an elevator while its programmers work out the kinks.

Java wasn’t catching on as an appliance development tool, but just as things were looking grim for the Green project, the World Wide Web started to take off. Many things that made Java good for the Star 7 turned out to be good for the Web:

To demonstrate Java’s potential, in 1994, project members created HotJava, a web browser that could run Java applets. The browser demonstrated two things about Java: what it offered the Web and what kind of program Java could create. Green programmers had used their new language to create the browser instead of implementing it in C++.

Netscape became the first company to license the Java language in August 1995, incorporating a Java interpreter in its then-leading Navigator web browser. Microsoft followed by licensing Java for Internet Explorer. Millions of people could run interactive programs in their browsers for the first time.

Spurred by this huge audience of web users, thousands of people learned Java programming and Sun added hundreds of employees to its Java effort, believing that the language was ideally suited for a wide variety of computing platforms beyond the Web.

Sun has released seven versions of the Java language:

The features described in the preceding list are part of the Java Standard Edition, the most popular edition of the language, which has a target audience of software developers working in a variety of corporate, academic, and governmental environments.

There are also two other editions:

This book covers the Standard Edition, which is the best mix of features for the largest audience of Java developers and the people they write software for.

It gives special emphasis to the Java Development Kit (JDK), a free development tool available from Sun’s Java website at http://java.sun.com.

The JDK, which is free, is the first development tool that supports new versions of Java.

In addition to the JDK, more than two dozen commercial development tools are available for Java programmers. The following are some of the most popular:

If you are going to use something other than the JDK to create Java programs as you read this book, you need to make sure that your development tool is up to date in its support for Java 6. Many of these tools can be configured to work automatically with new JDK releases.

Anyone who can accurately predict the future of Java should be going after venture capital instead of writing a book. The technology firm Kleiner, Perkins, Caufield, and Byers (KPCB) created a fund to invest $100 million in startup companies on the basis of their future plans involving Java, distributing millions to Marimba, Resonate, and a dozen other companies.

With the caveat that neither author of this book is pursuing venture capital, we predict a bright future for Java over the coming decade.

The new version of Java incorporates the following key improvements:

You work with these and other new features in this book.

If you’re not yet familiar with object-oriented programming, you get plenty of chances to become so during the first week of this book.

Object-oriented programming (OOP) is a way of conceptualizing a computer program as a set of separate objects that interact with each other. An object contains both information and the means of accessing and changing that information—an efficient way to create computer programs that can be improved easily and used later for other tasks.

Java inherits many of its object-oriented concepts from C++ and borrows concepts from other object-oriented languages as well.

In part, Java was first created at the Green project in rejection of the complexity of C++. C++ is a language with numerous features that are powerful but easy to employ incorrectly.

Java was intended to be easier to write, compile, debug, and learn than other objectoriented languages. It was modeled strongly after C++ and takes much of its syntax from that language.

Despite Java’s similarities to C++, the most complex and error-prone aspects of that language have been excluded from Java. You won’t find pointers or pointer arithmetic because those features are easy to use incorrectly in a program and even more difficult to fix. Strings and arrays are objects in Java, as is everything else except a few primitive data structures such as integers, floating-point numbers, and characters.

Memory management, also called garbage collection, is handled automatically by Java rather than requiring programmers to allocate and deallocate memory. Perhaps the biggest difference between the languages is that multiple inheritance is not supported in Java.

Experienced C++ programmers will undoubtedly miss these features as they start to use Java, but everyone else will learn Java more quickly because of their absence and write more reliable programs.

Although Java is easier to learn than many other languages, a person with no programming experience at all will find Java challenging. It is more complicated than working in something such as HTML or JavaScript, but definitely something a beginner can accomplish.

Because it was created to run on a wide variety of devices and computing platforms, Java was designed to be platform neutral, working the same no matter where it runs.

This was a huge departure in 1995, when Visual C++, Visual Basic, and other leading programming environments were designed almost exclusively to support versions of Microsoft Windows.

The original goal for Java programs to run without modification on all systems has not been realized. Java developers routinely test their programs on each environment they expect it to be run on, and sometimes they are forced into cumbersome workarounds as a result. Even different versions of the same web browser can require this kind of testing. Java game programmer Karl Hörnell calls it a “hopeless situation.”

However, Java’s platform-neutral design still makes it much easier to employ Java programs in a diverse range of different computing situations.

As with all high-level programming languages, Java programs are originally written as source code, a set of programming statements entered into a text editor and saved as a file.

When you compile a program written in most programming languages, the compiler translates your source file into machine code—instructions specific to the processor your computer is running. If you compile your code on a Windows system, the resulting program will run on other Windows systems but not on Macs, Palm Pilots, and other machines. If you want to use the same program on another platform, you must transfer your source code to the new platform and recompile it to produce machine code specific to that system. In many cases, changes to the source are required before it compiles on the new machine because of differences in its processors or operating system functionality and other factors.

Java programs, on the other hand, are compiled into machine code for a virtual machine—a program that acts as a sort of computer within a computer. This machine code is called bytecode, and the virtual machine takes this code as input and carries out each instruction.

The virtual machine is commonly known as the Java interpreter, and every environment that supports Java must have an interpreter tailored to its own operating system and processor.

Java is also platform neutral at the source level. Java programs are saved as text files before they are compiled, and these files can be created on any platform that supports Java. For example, you could write and compile a Java program on a Windows XP machine, upload it to a Linux machine over the Internet, and run the compiled version.

Java interpreters can be found in several places. For applets, the interpreter is either built into a Java-enabled browser or installed separately as a browser plug-in.

If you’re used to the way other languages create platform-specific code, you might think the Java interpreter adds an unnecessary layer between your source file and the compiled machine code.

The interpreter does cause some performance issues—as a rule, Java bytecode executes more slowly than platform-specific machine code produced by a compiled language, but each version of the language brings better speed, as does each new generation of processors.

For some Java programs, speed might not be as much of an issue as portability and ease of development. The widespread deployment of Java in large business and government projects shows that the loss in speed is less of an issue than it was for early versions of the language.

Java is a different language today than it was in 1995.

This has a good side—there’s a well-established market for Java programmers, and the skills are in strong demand.

This also has a bad side—Java is 20 times larger today than it was on its first release, so there’s much more to learn.