An important distinction to make in Java programming is where your program is supposed to be running. Some programs are intended to work on your computer; you type in a command or click on an icon to start them up. Other programs are intended to run as part of a World Wide Web page. You encountered several examples of this type of program during the previous hour's whirlwind vacation.
Java programs that run locally on your own computer are called applications. Programs that run on Web pages are called applets. During this hour, you'll learn why that distinction is important, and the following topics will be covered:
Although Java has become well-known because it can be used in conjunction with World Wide Web pages, you can also use it to write any type of computer program. The BigDebt program that you wrote during Hour 2, "Writing Your First Program," is an example of a Java application.
To try out another program, use your word processor to open up a new file and enter everything from Listing 4.1. Remember not to enter the line numbers and colons along the left-hand side of the listing; these items are used to make parts of programs easier to describe in the book. When you're done, save the file as Root.java.
1: class Root {
2: public static void main(String[] arguments) {
3: int number = 225;
4: System.out.println("The square root of "
5: + number
6: + " is "
7: + Math.sqrt(number) );
8: }
9: }
Before you can test out this application, you need to compile it with the javac
compiler tool. While in the same directory as the Root.java file, compile
it with the following command:
javac Root.java
If you have entered Listing 4.1 without any typos, including all punctuation and every word capitalized as shown, it should compile without any errors. The javac compiler responds to a successful compilation by not responding with any message at all.
You run Java applications in the same way you would run any program that's installed on your computer. Because they require the use of the java interpreter to run, the most common way that you'll run a Java program is probably by typing a command like the following at a command-line prompt:
java DrumMachine
This command would cause the java interpreter to look for a Java program called DrumMachine.class in the current directory. If it found one, it would start running it. To run the Root application, type the following:
java Root
The output should resemble the following:
The square root of 225 is 15.0
When you run a Java application, the interpreter looks for a main() block and starts handling Java statements at that point. If your program does not have a main() block, as most applets do not, the interpreter will respond with an error.
Because Java applications are usually run from a command line, you can send information to applications at the same time that you run them. The following example uses the java interpreter to run an application called DisplayTextFile.class, and it sends two extra items of information to the application: readme.txt and /p:
java DisplayTextFile readme.txt /p
The extra information you can send to a program is called arguments. The first argument, if there is one, is provided one space after the name of the application. Each additional argument is also separated by a space. You can send as many arguments as you want to a Java application. In order to do something with them, however, you have to write some statements in the application to handle them.
To see how arguments work in an application, create a new file in your word processor called NewRoot.java. Enter the text of Listing 4.2 into the file and save it when you're done. Compile the program with the javac compiler tool, while correcting any errors that are caused by typos.
1: class NewRoot {
2: public static void main(String[] arguments) {
3: int number = 0;
4: if (arguments.length > 0)
5: number = Integer.parseInt( arguments[0] );
6: System.out.println("The square root of "
7: + number
8: + " is "
9: + Math.sqrt(number) );
10: }
11: }
This program is similar to the Root program except for Lines 3-5. Don't
worry about the specific statements used in these lines; they use some advanced features.
What's important to note is what these lines are accomplishing: If an argument is
sent to the NewRoot program when it is run, the argument is stored in the
number variable.
To try the program out, use the Java interpreter with a command such as the following:
java NewRoot 169
This command causes the output to report that the square root of 169 is 13.0. Try the program several times with different numbers.
Arguments are a useful way to customize the performance of a program. They are often used to configure a program so that it runs a specific way. Java applications use arguments, but applets use a different way to receive information as they are run.
Applets--programs that can run on World Wide Web pages--were the thing that made Java a computer magazine cover subject upon its release. Applets put a spotlight on the ways that Java was different and remarkable. Before Java, World Wide Web pages were a combination of text, images, and forms that used gateway programs running on the computer that hosted the pages. These gateway programs required special access to the Web page server machine, so most Web users did not have the ability to use them. Writing them required even more expertise.
In contrast, programmers of all skill levels can write Java applets, and you'll write several during the span of these 24 hours. You can test applets with any Web browser that handles Java programs and put one on a Web page without any special access from a Web provider. The Java programs that you toured during the previous hour were all applets. Their structure differs from applications in several important ways, and they are designed specifically for presentation on the World Wide Web.
As stated previously, applets do not have a main() block like applications do. Applets have several different sections that are handled depending on what is happening in the applet. These sections are detailed fully during Hour 13, "Learning How Applets Work." Two of the sections are the init() block statement and the paint() block. init() is short for initialization, and it is used to set up anything that needs to be set up as an applet first runs. The paint() block is used to display anything that should be displayed.
To see an applet version of the Root application, create a new file in your word processor and call it RootApplet.java. Enter the code in Listing 4.3; save it when you're done. Compile the file with the javac compiler tool by typing the following:
javac RootApplet.java
1: public class RootApplet extends java.applet.Applet {
2: int number;
3:
4: public void init() {
5: number = 225;
6: }
7:
8: public void paint(java.awt.Graphics g) {
9: g.drawString("The square root of " +
10: number +
11: " is " +
12: Math.sqrt(number), 5, 50);
13: }
14: }
This program contains a lot of the same statements as the Java application that did
the same thing. The main difference is in how it is organized--the main()
block has been replaced with an init() block and a paint() block.
The sample programs in this hour are provided primarily to introduce you to the way Java programs are structured. Some aspects of these programs will be introduced fully later, so don't feel like you're falling behind. The main purpose of this hour is to get the programs to compile and see how they function when you run them.
Unlike applications, compiled Java applets cannot be tested using the java interpreter tool. You have to put them on a Web page and view that page in one of two ways:
To create a Web page that can display the RootApplet program, return to your word processor and create a new file. Enter Listing 4.4 in that file and save it as RootApplet.html.
1: <applet code="RootApplet.class" height=100 width=300>
2: </applet> This Web page contains the bare minimum needed to display a Java applet on a Web page. The <APPLET> tag is used to specify that a Java program is being put on the page, the code attribute provides the name of the applet, and the height and width attributes describe the size of the applet's display area. These items will be described in detail during Hour 13.
For now, use the appletviewer tool to take a look at this page. Type the following at the command line:
appletviewer RootApplet.html
Figure 4.1 shows what the applet looks like using appletviewer.
Figure 4.1. The RootApplet applet displayed with the appletviewer tool.
Java applets are never run from the command line, so you can't specify arguments the way you can with applications. Applets use a different way to receive information at the time the program is run. This information is called parameters, and you can send parameters through the HTML page that runs the applet. You have to use a special HTML tag for parameters called <PARAM>.
Load the file RootApplet.java back into your word processor. The init() block of the program should resemble the following:
public void init() {
number = 225;
}
Replace these three lines with the following statements:
public void init() {
String parameter = getParameter("NUMBER");
if (parameter != null)
number = Integer.parseInt(parameter);
}
Save the file and then compile it by typing the following at the command line:
javac RootApplet.java
Before you can try this change out, you need to modify the Web page RootApplet.html so that it sends a parameter. Load the page into your word processor and add a line between the <APPLET> line and the </APPLET> line, so that the code resembles the following:
<applet code="RootApplet.class" height=100 width=300> <param name="NUMBER" value=196> </applet>
Save the file when you're done, and load the page using appletviewer again. The output should resemble Figure 4.2. Change the value of the VALUE attribute in the RootApplet.html file and run the program again. Try this several times, and you'll see that your program is now flexible enough to handle any number.
Figure 4.2. The modified RootApplet program displayed with appletviewer.
You can use as many parameters as needed to customize the operation of an applet, as long as each has a different NAME attribute specified along with the <PARAM> tag.
As a brief workshop to better familiarize yourself with the <APPLET> tag and how it can be used to alter the performance of an applet, visit this book's World Wide Web site at the following address:
http://www.prefect.com/java24
Visit this site using either the current version of Netscape Navigator or Microsoft Internet Explorer. Go to the section of the site labeled Hour 4 Showcase, and you'll be given a guided tour through several working examples of applets. On each of these pages, you can use a pull-down menu command to view the HTML tags that were used to create the page. With Navigator, the command is View | Document Source, and with Internet Explorer, the command is View | Source. Compare the parameters that are used with each applet to the way the applet runs.
Appendix C, "This Book's Web Site," describes other things you can do on this book's site. The Web site is intended as a complement to the material covered in this book and a way to find out about corrections, revisions, or other information that makes these 24 hours more productive.
During this hour, you got a chance to create both a Java application and an applet. These two types of programs have several important differences in the way they function and the way they are created. The next several hours will continue to focus on applications as you become more experienced as a Java programmer. Applications are easier to test because they don't require you to create a Web page to view them; they can be easier to create as well. The last several hours of the book focus on applets, however, because that's the area where beginning programmers are most likely to want to put their skills to work.
Test your knowledge of the material covered in this chapter by answering the following questions.
If you'd like to apply your acumen of applets and applications, do the following activities:
