Copyright ©1996, Que Corporation. All rights reserved. No part of this book may be used or reproduced in any form or by any means, or stored in a database or retrieval system without prior written permission of the publisher except in the case of brief quotations embodied in critical articles and reviews. Making copies of any part of this book for any purpose other than your own personal use is a violation of United States copyright laws. For information, address Que Corporation, 201 West 103^rd Street, Indianapolis, IN 46290 or at support@mcp .com.

Notice: This material is excerpted from Special Edition Using Java, ISBN: 0-7897-0604-0. The electronic version of this material has not been through the final proof reading stage that the book goes through before being published in printed form. Some errors may exist here that are corrected before the book is published. This material is provided "as is" without any warranty of any kind.

Chapter 15 - The Basics of Applet Construction

by Mary Pietrowicz

Until recently, the Web had static documents made up of text and graphics-period. If you wanted to do something more interesting, you had to rely on an external application launched from the browser. Often, users didn't have these applications available.

Now, you are no longer limited to mere text and graphics. Today's browsers can run programs written in Java called applets. Using Java applets, browsers can run animations, play audio, and interact with the user. Anyone with a Java-capable browser can run an applet, no matter what kind of computer they have. And, your users don't have to install anything. They just load the page that contains your applet.

In this chapter, you will learn

The parts of a simple applet
The difference between instance variables and class variables
The way to control access to variables and methods in applets
The capabilities the Applet class gives to applets
The lifecycle of an applet
The limitations of applets

Preparing to write Applets

Consider writing an applet when you:
Need something other than static text and graphics. For example, an applet that calculates monthly mortgage payments would be useful on a page that posts current interest rates.
Need "flash" factor. Attention-grabbing animations, sounds, and executable programs are useful for announcements and advertisements.
Want to make an application readily available on the web to all kinds of people using all kinds of machines.

First, you'll need to create a development environment for your applets. At a minimum, you'll need places to put the applet code, sound files, images, and associated HTML pages.

In our discussion and examples, we will use the following directories:

/html For .html files

/html/audio For .au files

/html/classes For .java and .classes files

/html/images For .gif or .jpeg image files

Before you try to write applets, make sure that Java is installed correctly.

See "The Java Environment," Chapter 2

Also make sure that you have either the Java appletviewer or a Java-capable browser available.

It's handy to have both the appletviewer and a Java-capable browser around when you are debugging an applet. Often it's faster to try out new code with the appletviewer, and any resulting error messages are easy to see.

A First Look at a Simple Applet

Let's look at a simple applet called "ImgSound." ImgSound displays a picture of a cat and plays a "meow" sound until the reader leaves the page. Figure 15.1 shows what ImgSound looks like when it's running.

Fig. 15.1
The ImgSound applet displays a picture of a cat and plays a "meow" sound while it is running.

ImgSound's files fit into the development environment as shown in Table 15.1 below.Table 15.1 Location of ImgSound Files in the Development Environment

Directory       ImgSound Files
/html   ImgSound.html
/html/audio     meow.au
/html/classes   ImgSound.class
        ImgSound.java
/html/image     cat.gif

Including an applet in HTML

To include an applet in an HTML document, insert an <APPLET> </APPLET> tag pair at the point where the applet should go. Listing 15.1 below shows how ImgSound.html includes the ImgSound applet.

The <APPLET> element specifies five things:

The name of the applet,
The directory containing the applet code, relative to the HTML document,
The width in pixels of the applet,
The height in pixels of the applet, and
The parameters passed to the applet.

To display a different image and play another sound, just change the "value=" assignments in the PARAM statements below.

Listing 15.1  ImgSound.html includes the ImgSound Applet.
<HTML>
<HEAD>
<TITLE> Meowing Cat Applet </TITLE>
</HEAD>
<BODY>
<P>
The Cat's Meow...
<P>
<HR>
<APPLET code="ImgSound.class" codebase="./classes" width=500 height=400>
<PARAM name=picture-url value=../image/cat.gif>
<PARAM name=sound-url value=../audio/meow.au >
</APPLET>
<HR>
</BODY>
</HTML>

You can do much more with the <APPLET> tag. If you want to learn more about the <APPLET> tag, skip ahead to chapter 20, "Adding an Applet to an HTML Document".

Examining the ImgSound Applet

Examine the ImgSound applet in listing 15.2 below. ImgSound loads an image called cat.gif (a picture of a cat)and a sound called meow.au. After initialization is complete, the applet displays the cat picture and meows. The applet will continue to meow the user leaves the page or selects the browser and presses any keyboard key. The meowing will resume when the user re-enters the page.

Listing 15.2  ImgSound.java Displays an Imange and Plays a Sound.
// ImgSound
//
// Description:
//    ImgSound is an applet that displays an image and plays a sound when 
//    the applet starts.

import java.awt.*;
import java.applet.*;
import java.net.*;

public class ImgSound extends java.applet.Applet
{
  // URLs
  private String img_url = null;
  private String sound_url = null;

  // Panels and canvases that the applet uses.
  Canvas c_north = null;

  // Images that the applet uses.
  Image img_1 = null;

  // Sounds that the applet uses.
  AudioClip sound_clip = null; 

  // The background color
  Color bkgnd;

  public void init()
  {
    // Set up the display.
    setLayout(new BorderLayout());
    bkgnd = new Color(255, 255, 255);  // White
    setBackground(bkgnd);
    c_north = new Canvas();
    add("North", c_north);

    // Read in the parameters from the HTML document.
    img_url = getParameter("picture-url");
    sound_url = getParameter("sound-url");
   
    // Load image and sound clip. 
    MediaTracker tracker = new MediaTracker(this);
    img_1 = getImage(getCodeBase(), img_url);
    tracker.addImage(img_1, 0);
    try
    { tracker.waitForID(0); }
    catch (InterruptedException e)
    { System.out.println("Image Load Failure"); }

    sound_clip = getAudioClip(getCodeBase(), sound_url);

  }

  public void start()
  {
      // Play the sound over and over.
      sound_clip.loop();
  }

  public void stop()
  {
     // Quiet.
     sound_clip.stop();
  }

  public void paint(Graphics g)
  {
     if (img_1 != null)
     {
        g.drawImage(img_1, 0, 0, getBackground(), c_north);
     }
  }

  public boolean keyDown(Event evt, int key)
  {
     // Quiet.
     sound_clip.stop();
     return true;
  }
}

ImgSound has four main components:

Import statements,
A class definition,
Variables, and
Methods.

The import statements let your applet use Java classes and methods. They are similar to "#include" directives in C.

All applets must import java.applet.Applet in the file that contains the applet class definition. Including java.applet.* will include java.applet.Applet. Applets with user interfaces (most applets!)will include java.awt.*, too.

This applet's class definition is:

public class ImgSound extends java.applet.Applet

A different applet "X" would have a similar applet class definition:

public class X extends java.applet.Applet

Note that all applet class definitions extend java.applet.Applet.

Because ImgSound "extends java.applet.Applet", ImgSound inherits all of java.applet.Applet's methods and variables.

Look for the variable definitions img_url, sound_url, c_north, img_1, sound_clip, and bkgnd. Find the methods init(), start(), stop(), paint(Graphics g), and keyDown(Event evt, int key). Each variable and method is inside the ImgSound class. All applet variables and methods belong to and are declared inside of a class.

Let's take a closer look at ImgSound's methods.

The init() method makes the applet ready to run. It reads parameters, sets up the display, and reads in the image and sound clip. These activities happen only once. They do not need to be repeated if the applet stops temporarily.

In this case, start() is very simple. It just plays a sound over and over. start() is the point of entry if ImgSound temporarily starts and resumes.

The stop() method stops the sound from playing. stop() is the point of exit if ImgSound stops temporarily.

The paint(Graphics g) draws the image on the display.

The keyDown(Event evt, int key) method stops the meow sound when the user selects the applet and presses a keyboard key.

Applets that make noise like this one can be annoying. It's a good idea to provide a way to stop the noise. The method keyDown(Event evt, int key)in ImgSound stops the noise when a key is pressed. Just select the applet by clicking on it, then press any keyboard key.

Variables and Methods

As we saw in the previous example, Java variables are always declared within the boundaries of a class. If their declarations appear inside a method, then they are visible only in the method. We will focus on variables declared outside of methods. They belong to the class. We will learn the difference between class and instance variables. We will also learn how to control access to variables and methods.

The information in this section applies to both applets and applications.

Instance Variables vs Class Variables

Java allocates new space in memory for instance variables whenever new objects are instantiated from classes. In contrast, Java allocates space for class variables only once per class.

For example, the class "Secret Numbers" below stores 3 numbers of a secret code or combination.

class Secret_Numbers
{
   int first = 0;
   int second = 0;
   int third = 0;
}

An applet code segment could create new secret numbers for anyone who needed a combination. For example,

Secret_Numbers Steves_numbers = new Secret_Numbers();
Steves_numbers.first = 1;
Steves_numbers.second = 2;
Steves_numbers.third = 3;

Secret_Numbers Marys_numbers = new Secret_Numbers();
Marys_numbers.first = 4;
Marys_numbers.second = 5;
Marys_numbers.third = 6;

The two sets of numbers are distinct. With the two "new" commands, Java has created two objects with space for two copies of the integers "first", "second", and "third." If we print Steves_numbers and Marys_numbers, they have different values. An applet code segment that prints the numbers looks like this:

System.out.println("Steves_numbers.first = "+Steves_numbers.first);
System.out.println("Steves_numbers.second = "+Steves_numbers.second);
System.out.println("Steves_numbers.third = "+Steves_numbers.third);
System.out.println("Marys_numbers.first = "+Marys_numbers.first);
System.out.println("Marys_numbers.second = "+Marys_numbers.second);
System.out.println("Marys_numbers.third = "+Marys_numbers.third);

The printed output looks like this:

Steves_numbers.first = 1
Steves_numbers.second = 2
Steves_numbers.third = 3
Marys_numbers.first = 4
Marys_numbers.second = 5
Marys_numbers.third = 6

In short, Java creates an object with space for instance variables every time a class is instantiated with the "new" command.

In contrast, Java allocates space for class variables only once. Each instance of the class shares the class variables. An instance that changes a class variable value changes the value for all instances!

The keyword "static" in a variable declaration indicates a class variable. Let's modify the "Secret_Numbers" class so that each of its variables is a class variable.

class Secret_Numbers
{
  static int first = 0;
   static int second = 0;
   static int third = 0;
}

As before, we assign the secret numbers.

Secret_Numbers Steves_numbers = new Secret_Numbers();
Steves_numbers.first = 1;
Steves_numbers.second = 2;
Steves_numbers.third = 3;

Secret_Numbers Marys_numbers = new Secret_Numbers();
Marys_numbers.first = 4;
Marys_numbers.second = 5;
Marys_numbers.third = 6;

The printed output is different!

Steves_numbers.first = 4
Steves_numbers.second = 5
Steves_numbers.third = 6
Marys_numbers.first = 4
Marys_numbers.second = 5
Marys_numbers.third = 6

Steves_numbers and Marys_numbers are the same because the two instances share the same copies of the variables first, second, and third.

Controlling Access to Variables and Methods

Access control determines how applets can read and modify variables and call methods. The examples below show how to enable or prevent access among the classes and subclasses in your applets. Java makes decisions about access based on whether

The variable is in the same class as the reference
The variable is in the same package as the reference
The variable is a superclass of the reference
The variable is a subclass of the reference

Java provides the following keywords for controlling access.

private
public
protected
private protected

"Private" means that references are illegal outside the scope of the immediate class. "Public" means that references are legal anywhere. The "protected" modifier, in general, limits references to the scope of the class, its subclasses, and the class's package. A subclass, however, can't access a superclass's protected variables. The "private protected" modifier limits references to the scope of the class and its subclasses.

If no keywords are used, then references are legal within the package. Sometimes this is called "friendly" access.

Now let's look at some examples. We've modified the Secret_Numbers class to contain another number, a method to print all the numbers, and a method to print the first number. What else has changed? The methods and variables have access modifiers.

Listing 15.3  Secret_Numbers.java shows how to apply access modifiers to variables and methods
package A;

public class Secret_Numbers
{
   private int first = 0;
   private protected int second = 0;
   protected int third = 0;
   public int fourth = 0;

   void print_secret_numbers()
   {
      System.out.println("first = "+first);
      System.out.println("second = "+second);
      System.out.println("third = "+third);
      System.out.println("fourth = "+fourth);
   }

   private protected void print_first()
   {
      System.out.println("first = "+first);
   }
}

What happens if a class Get_Secrets from the same package tries to access Secret_Number's variables and methods?

Get_Secrets can access "third," "fourth," and "print_secret_numbers()". Accessing "third" and "print_secret_numbers()" is legal because Get_Secrets and Secret_Numbers belong to the same package. The variable "fourth" is accessible from any class because it is public.

Get_Secrets cannot access "first," "second," and "print_first()". The variable "first" is private, so no other class can access it directly. "second" and "print_first()" are out of reach because Get_Secrets is not a subclass of Secret_Numbers.

Listing 15.4  Get_Secrets tries to access Secret_Numbers's variables and methods
package A; 

import A.Secret_Numbers;

public class Get_Secrets
{
   void get_all(Secret_Numbers nums)
   {
     int a = nums.first;             // Illegal - can't access a private variable directly.
     int b = nums.second;            // Illegal - Get_Secrets is not a subclass of Secret_Numbers.
     int c = nums.third;             // OK
     int d = nums.fourth;            // OK
     nums.print_secret_numbers();    // OK
     nums.print_first();             // Illegal - Get_Secrets is not a subclass of Secret_Numbers.
   } 
}

What happens if a class from another package, Safecracker, tries to access Secret_Number's variables and methods?

Since Safecracker is not a subclass of Secret_Numbers, it can't access "print_first()" and "second". Since Safecracker doesn't belong to the same package, it can't access "print_secret_numbers()" and "third". Accessing "first," a private variable, is illegal. Accessing, "fourth," a public variable, is always legal.

This listing is Safecracker.java.

Listing 15.5  Class Safecracker tries to access Secret_Numbers's variables and methods
package B;

import A.Secret_Numbers;

class Safecracker
{
  void crack_safe(Secret_Numbers nums)
  {
    nums.print_secret_numbers();   // Illegal - Safecracker not in the same package as Secret_Numbers.
    nums.print_first();            // Illegal - Safecracker not a subclass of Secret_Numbers.
    int a = nums.first;            // Illegal - Can't access a private variable directly.
    int b = nums.second;           // Illegal - Safecracker not a subclass of Secret_Numbers.
    int c = nums.third;            // Illegal - Safecracker not in same package and not a subclass.
    int d = nums.fourth;           // OK
  }
}

Finally, what happens if a class from another package, Another_Num, tries to access Secret_Number's variables and methods? Note that Another_Num is a subclass of Secret_Number.

Another_Num can't access "print_secret_numbers()" because Another_Num and Secret_Numbers belong to different packages. It can't access "nums.first" because first is declared private, but it can access the public variable "nums.fourth." Another_Num can't access "nums.second" and "nums.third" because a subclass can't access a superclass's protected variables. Another_Num can, however, access it's own inherited copy of "third" and run it's own inherited "print_first()" method.

It's legal for a subclass to access it's own inherited copies of protected variables and methods. It's not legal, however, for a subclass to access a superclass's copy of the same protected variables and methods.

Listing 15.6  Class Another_Num tries to access Secret_Numbers's variables and methods
package B;

import A.Secret_Numbers;

class Another_Num extends Secret_Numbers
{
  int fifth = 0;

  public void get_other_numbers(Secret_Numbers nums)
  {
     nums.print_secret_numbers();    // Illegal - Another_Num not in the same package.
     int a = nums.first;             // Illegal - can't access a private variable directly.
     int b = nums.second;            // Illegal - can't access a superclass's private protected variables.
     int c = nums.third;             // Illegal - can't access a superclass's protected variables.
     int d = nums.fourth;            // OK

     this.print_secret_numbers();    // Illegal - not in same package.
     int e = this.third;             // OK - accessing the subclass's protected variable.
     this.print_first();             // OK - accessing the subclass's protected method.
  }
}

The Applet Class

As we saw in listing 15.2, applets are defined with the statement of the form

access_modifier class classname extends java.applet.Applet

This means that the applet "classname" inherits methods and variables from the Applet class.

A closer look reveals that the applet class itself inherits from a long chain of classes. In short, a class that extends java.applet.Applet can use variables and methods (including constructors)from java.lang.Object, java.awt.Component, java.awt.Container, and java.awt.Panel.

Take a minute to investigate which variables and methods are available to applets.

How to Use the Applet Class Methods

The methods in the applet class provide ways for applets to

Handle parameters,
Get images,
Get and play sound clips,
Interact with the browser or appletviewer, and
Manage lifecycle events cleanly, e.g., loading, starting, stopping, restarting, and quitting.

We have already used some of these methods in the previous examples.

Handling Parameters

The example in listing 15.1 shows how to pass parameters to an applet from an HTML document. Listing 15.2 shows how the applet code retrieves the parameters. The getParameter() method reads a parameter in an applet.

// Read in the parameters from the HTML document.
    img_url = getParameter("picture-url");
    sound_url = getParameter("sound-url");

Note that parameters are passed in as type String.

The getParameterInfo() method returns a string listing all the parameters the applet understands. For each parameter, the string specifies the name, type, and description.

Getting Images

The getImage(URL, String) method loads image files for the applet to use. For example, in listing 15.2, the line

img_1 = getImage(getCodeBase(), img_url);

loads the image img_url.

Getting and Playing Sound Clips

We have already seen the methods for getting audio clips. In listing 15.2, the line

sound_clip = getAudioClip(getCodeBase(), sound_url);

loads the applet's sound.

The play(URL, String) method plays a sound clip. If the sound has already been loaded, though, you can play it with the technique used in listing 15.2:

// Play the sound over and over.
      sound_clip.loop();

Interacting with the Applet's Environment

The getAppletContext() method returns an object you can use to get information about the environment and control the environment. Specifically, it returns type AppletContext (an interface). AppletContext methods allow you to

Find out what applets are running on the same page as your applet.
Get the context of another applet and run its methods.
Send messages to other applets.
Get images and audio clips.

The getAppletInfo() method lets you provide information about an applet. Override this method by putting something like this in your applet:

public String getAppletInfo()
{ return "Applet Name, version 1.0, date, author, copyright date"; }

We used getCodeBase in listing 15.2. The line

img_1 = getImage(getCodeBase(), img_url);

uses getCodeBase() to get the URL of the directory containing ImgSound. The getImage method constructs the image URL from getCodeBase() and img_url.

The getDocumentBase() method is similar to getCodeBase(), except that getDocumentBase() returns the URL to the directory containing the applet's HTML document.

There are many more methods in the applet class for interacting with the applet's environment:

The isActive() method determines whether an applet is active. Use this method to check the state of another applet by calling AppletContext(), calling getApplets() on the context, and calling isActive on a particular applet.
Use SetStub() to set up a new AppletStub interface. Implementors of new applet viewers will use this.
Use ShowStatus(String) to post messages into the browser's status area.
The resize(Dimension) method resizes an entire applet.

Managing an applet's lifecycle

Java provides a mechanism for applets to take control at key moments when certain events occur. The init(), start(), stop(), and destroy() methods are called when the applet loads, begins executing, stops executing, and unloads, respectively. If an applet needs to do something at one of these key stages, just override the method by including your own implementation of it in the applet.

Let's take a closer look at these methods in the next section.

The structure of an applet

The applet class and its superclasses provide methods that the system calls when key events occur. When we want to do something in response to an event, we just override the corresponding method. Suppose that an applet needed to print the word "Beep!" when the user pressed the mouse button. Since the system calls mouseDown(event, int, int) when the user presses a mouse button, we would override the mouseDown method in component by putting a method in our applet with the same format.

public boolean mouseDown(Event evt, int x, int y)
{ System.out.println("Beep!"); }

The system calls methods for "lifecycle" events, too. When an applet loads, the system calls the init() method. When initialization is complete, the system calls the start()routine to begin execution. The system also calls start()to resume execution. The stop()method is called to halt execution, and the destroy()method is called to do any remaining cleanup before the applet is unloaded.

Entering the applet's page causes the system to call start(), and exiting the applet's page causes the system to call stop().

You can use your own stop() method to stop things like sounds, display updates, and calculations. Users won't be able to appreciate display updates to your applet if they are no longer viewing the applet. Users will be very annoyed if an applet continues to make noise after they have left the page, too!

Applets selectively override these methods. Most applets will have an init() method to do a one-time initialization. This is the place to initialize variables, load images, etc.

Think of an applet as a dark room in your house. When you buy the house, you connect the electricity (init). When you go into the room, you turn on the light (start). When you leave the room, you turn the light off (stop). When you sell the house, you disconnect the electricity (destroy).

Listing 15.7 below shows how an applet moves from state to state. This applet is ImgSound from the previous example-with a few modifications. The applet ImgSound2 overrides init(), start(), stop(), and destroy(). Whenever the system calls one of these methods, it plays an appropriate sound (a different one for each method). It also appends "initializing", "starting up", "stopping", or "destroying" to a text area at the bottom of the screen. When the applet loads, you will see "Initializing. Starting up." in the text window and will hear sound clips for the init()and start() methods. Figure 15.2 shows the ImgSound2 applet running.

Fig. 15.2
The ImgSound2 Applet displays state change information and plays sounds to mark changes in state.

If you leave the page and return later, you will see that the text window has changed. Before, the text window just displayed "Initializing. Starting Up." Now it says, "Initializing. Starting Up. Stopping. Starting Up." When you left the applet's page, the stop() method ran, appended "Stopping." to the text area on the screen, and played the audio clip for the stop() method. When you returned, the start() method ran again, appended "Starting Up." to the text area, and played the audio clip for the start() method. Figure 15.3 shows how the text area changes when you leave the applet's page and return later.

Fig. 15.3
The ImgSound2 Applet text shows that you have left the page and returned; "Stopping. Starting Up." has been appended.

Listing 15.7  ImgSound2.java tracks the applet lifecycle.
// ImgSound2
//
// Description:
//    ImgSound2 is an applet that displays an image and plays a sound when 
//    the applet starts.  It also displays the state trail of the applet.
//    When the applet changes states, it plays a sound clip indicating
//    the state just entered.

import java.awt.*;
import java.applet.*;
import java.net.*;

public class ImgSound2 extends java.applet.Applet
{
  // URLs
  private String img_url = null;
  private String start_url = null;
  private String stop_url = null;
  private String init_url = null;
  private String destroy_url = null;

  // Display objects that the applet uses.
  Canvas c_north = null;
  TextField tf_south = null;
  StringBuffer str = null;

  // Images that the applet uses.
  Image img_1 = null;

  // Sounds that the applet uses.
  AudioClip init_clip = null; 
  AudioClip start_clip = null;
  AudioClip stop_clip = null;
  AudioClip destroy_clip = null;

  // The background color
  Color bkgnd;

  // Minimum delay time between sounds
  Long time_delay;


  // Workspace
  String scratch;

  public void init()
  {
    // Read parameters passed in from HTML document.
    img_url = getParameter("picture-url");
    init_url = getParameter("init-url");
    start_url = getParameter("start-url");
    stop_url = getParameter("stop-url");
    destroy_url = getParameter("destroy-url");
    scratch = getParameter("delay");
    time_delay = new Long(scratch);

    // Set up the screen.
    setLayout(new BorderLayout());
    bkgnd = new Color(255, 255, 255);  // White
    setBackground(bkgnd);
    c_north = new Canvas();
    tf_south = new TextField();
    add("North", c_north);
    add("South", tf_south);

    // Read in images.
    MediaTracker tracker = new MediaTracker(this);
    img_1 = getImage(getCodeBase(), img_url);
    tracker.addImage(img_1, 0);
    try
    { tracker.waitForID(0); }
    catch (InterruptedException e)
    { System.out.println("Image Load Failure"); }

    // Read in sound clips.
    init_clip = getAudioClip(getCodeBase(), init_url);
    start_clip = getAudioClip(getCodeBase(), start_url);
    stop_clip = getAudioClip(getCodeBase(), stop_url);
    destroy_clip = getAudioClip(getCodeBase(), destroy_url);

    // Display the state, and play audio indicator.
    str = new StringBuffer("Initializing. ");
    tf_south.setText(str.toString());
    init_clip.play();
    this.delay(time_delay.longValue());
  }

  public void start()
  {
      // Display the state.
      str  = str.append("Starting up. ");
      tf_south.setText(str.toString());

      // Play "start" audio indicator.
      start_clip.play();
      this.delay(time_delay.longValue());
  }

  public void stop()
  {
     // Display the state.
     str = str.append("Stopping. ");
     tf_south.setText(str.toString());

     // Play "stop" audio indicator.
     stop_clip.play();
     this.delay(time_delay.longValue());
  }

  public void destroy()
  {
     // Display the state.
     str = str.append("Destroying. ");
     tf_south.setText(str.toString());

     // Play "destroy" audio indicator.
     destroy_clip.play();
     this.delay(time_delay.longValue());
  }

  public void paint(Graphics g)
  {
     if (img_1 != null)
     {
        g.drawImage(img_1, 0, 0, getBackground(), c_north);
     }
  }

  private void delay(long wait_time)
  {
     for (int i=0; i<wait_time; i++)
     { i=i+1; }
  }
}

An Applet Template

Let's take what we've learned, generalize, and create a template for building applets.

First, a Java applet must include the appropriate import statements. The most common import statements are provided in the Template below. Just uncomment what you need. If only a few objects from a package are needed, include the objects explicitly instead. For example, the statement

import java.applet.Applet;

includes the Applet class and nothing else from the applet package.

Next, be sure to include a class definition that "extends java.applet.Applet". This is the main class for the applet.

Then, list instance variables, class variables, and methods. The variables and methods can appear in any order, but grouping the variables in one section and the methods in another make the code easy to read.

Finally, decide which methods the applet needs to override. Consider at least init(), start(), stop(), destroy(), and paint(). These are frequently replaced.

Listing 15.4  ImgSound2.java tracks the applet lifecycle.
// Name of Class (the file name and class name should be the same)
//
// Description:
//    Insert an appropriate description.  
// 

// Import Statements:
// Uncomment what you need to include, or insert a statement to import
// a specific item, e.g., "import java.applet.Applet;".

// import java.applet.*;
// import java.awt.*;
// import java.awt.image.*;
// import java.awt.peer.*;
// import java.io.*;
// import java.lang.*;
// import java.net.*;
// import java.util.*

// Top-level class declaration for the applet.
public class Template extends java.applet.Applet
{
  //  Insert instance variable declarations here. 


  //  Insert methods here.
  

  //  Methods you might need to override.
  //  public void init()
  //  {
  //  }

  //  public void start()
  //  {
  //  }

  //  public void stop()
  //  {
  //  }

  //  public void destroy()
  //  {
  //  }

  //  public void paint(Graphics g)
  //  {
  //  }
}
A Template for Writing Applets

Applet Limitations

Before you roll up your sleeves and rush into writing applets, let's take a minute to understand what an applet can't do. In general, applets loaded from the network are not allowed access to the local machine. Most limitations are there-on purpose-for security reasons.

Applets can't access files from the client machine.
Applets can't create files on the client machine.
Applets can't make network connects except back to the host machine where the applet came from.
Applets can't start any programs on a client machine.
Applets can't load libraries.
Applets can't define native method calls.
Applets can't halt execution of the interpreter (can't call System.exit()).

These limitations are necessary! The security restrictions prevent applets from doing harmful things across the net like;

Reading and downloading private files from machines.
Writing viruses or destroying data on machines.
Running potentially destructive programs on random machines on the network.
Talking directly to the client machine and making selective modifications.

This means you can't,

Post a useful file from a friendly network machine to the host machine, without the client machine having to run httpd.
Prompt the client machine to run helper routines for the applet.
Use files on the client.
4. Make a call to System.exit() for debugging or other purposes.

If applet restrictions prevent you from doing work you need to do, consider writing a Java application instead. Applications can make network connections, access files, run programs, go native, load libraries, and make calls to System.exit(). On the other hand, an applications don't have browsers built into them and don't have the ability to display HTML, jump to links, etc. Applications also are not as visible over the network as applets are. Weigh your requirements carefully when deciding between writing an applet and writing an application.

QUE Home Page

For technical support for our books and software contact support@mcp.com