Explain Applet Fundamentals, How Applet Works, What Is Applet, Program For Applet With Explanation
In This Topic & Blog Having Any Query Then Post your Comment and Suggestion Below
Applet Fundamentals
All of the preceding examples in this book have been Java console-based applications. However,
these types of applications constitute only one class of Java programs. Another type of program
is the applet. As mentioned in Chapter 1, applets are small applications that are accessed on an
Internet server, transported over the Internet, automatically installed, and run as part of a web
document. After an applet arrives on the client, it has limited access to resources so that it
can produce a graphical user interface and run complex computations without introducing
the risk of viruses or breaching data integrity.
Many of the issues connected with the creation and use of applets are found in Part II,
when the
applet
package is examined and also when Swing is described in Part III. However,
the fundamentals connected to the creation of an applet are presented here, because applets
are not structured in the same way as the programs that have been used thus far. As you
will see, applets differ from console-based applications in several key areas.
Let’s begin with the simple applet shown here:
import java.awt.*;
import java.applet.*;
public class SimpleApplet extends Applet {
public void paint(Graphics g) {
g.drawString("A Simple Applet", 20, 20);
}
}
This applet begins with two
import
statements. The first imports the Abstract Window
Toolkit (AWT) classes. Applets interact with the user (either directly or indirectly) through
the AWT, not through the console-based I/O classes. The AWT contains support for a
window-based, graphical user interface. As you might expect, the AWT is quite large
and sophisticated, and a complete discussion of it consumes several chapters in Part II of
this book. Fortunately, this simple applet makes very limited use of the AWT. (Applets can
also use Swing to provide the graphical user interface, but this approach is described later in
this book.) The second
import
statement imports the
applet
package, which contains the
class
Applet
. Every applet that you create must be a subclass of
Applet
.
The next line in the program declares the class
SimpleApplet
.
This class must be declared
as
public
, because it will be accessed by code that is outside the program.
Inside
SimpleApplet paint( )
,
is declared. This method is defined by the AWT and must
be overridden by the applet.
paint( )
is called each time that the applet must redisplay its
output. This situation can occur for several reasons. For example, the window in which the
applet is running can be overwritten by another window and then uncovered. Or, the applet
window can be minimized and then restored.
paint( )
is also called when the applet begins
execution. Whatever the cause, whenever the applet must redraw its output,
paint( )
is called.
The
paint( )
method has one parameter of type
Graphics
.
This parameter contains the graphics
context, which describes the graphics environment in which the applet is running. This context
is used whenever output to the applet is required.
Inside
paint( )
is a call to
drawString( )
, which is a member of the
Graphics
class.
This method outputs a string beginning at the specified X,Y location. It has the following
general form:
void drawString(String message , int x , int y )
Here, message is the string to be output beginning at x,y. In a Java window, the upper-left
corner is location 0,0. The call to
drawString( )
in the applet causes the message “A Simple
Applet” to be displayed beginning at location 20,20.
Notice that the applet does not have a
main( )
method. Unlike Java programs, applets
do not begin execution at
main( )
. In fact, most applets don’t even have a
main( )
method.
Instead, an applet begins execution when the name of its class is passed to an applet viewer
or to a network browser.
After you enter the source code for
SimpleApplet
, compile in the same way that you
have been compiling programs. However, running
SimpleApplet
involves a different process.
In fact, there are two ways in which you can run an applet:
• Executing the applet within a Java-compatible web browser.
• Using an applet viewer, such as the standard tool,
appletviewer
. An applet viewer
executes your applet in a window. This is generally the fastest and easiest way to
test your applet.
Each of these methods is described next.
To execute an applet in a web browser, you need to write a short HTML text file that
contains a tag that loads the applet. Currently, Sun recommends using the APPLET tag for
this purpose. Here is the HTML file that executes
SimpleApplet
:
<applet code="SimpleApplet" width=200 height=60>
</applet>
The
width
and
height
statements specify the dimensions of the display area used by the
applet. (The APPLET tag contains several other options that are examined more closely in
Part II.) After you create this file, you can execute your browser and then load this file, which
causes
SimpleApplet
to be executed.
To execute
SimpleApplet
with an applet viewer, you may also execute the HTML file
shown earlier. For example, if the preceding HTML file is called
RunApp.html
, then the
following command line will run
SimpleApplet
:
C:\>appletviewer RunApp.html
However, a more convenient method exists that you can use to speed up testing. Simply
include a comment at the head of your Java source code file that contains the APPLET tag.
By doing so, your code is documented with a prototype of the necessary HTML statements,
and you can test your compiled applet merely by starting the applet viewer with your Java
source code file. If you use this method, the
SimpleApplet
source file looks like this:
import java.awt.*;
import java.applet.*;
/*
<applet code="SimpleApplet" width=200 height=60>
</applet>
*/
public class SimpleApplet extends Applet {
public void paint(Graphics g) {
g.drawString("A Simple Applet", 20, 20);
}
}
With this approach, you can quickly iterate through applet development by using these
three steps:
1.
Edit a Java source file.
2.
Compile your program.
Execute the applet viewer, specifying the name of your applet’s source file. The applet
viewer will encounter the APPLET tag within the comment and execute your applet.
While the subject of applets is more fully discussed later in this book, here are the key
points that you should remember now:
• Applets do not need a
main( )
method.
• Applets must be run under an applet viewer or a Java-compatible browser.
• User I/O is not accomplished with Java’s stream I/O classes. Instead, applets use
the interface provided by the AWT or Swing.