Programming in Java: Applets

Applets

Console-based applications constitute only one class of Java programs. Another type of program is the applet. 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.

Two Types of Applets

It is important to state at the outset that there are two varieties of applets. The first are those based directly on the Applet class described in this chapter. These applets use the Abstract Window Toolkit (AWT) to provide the graphic user interface (or use no GUI at all). This style of applet has been available since Java was first created.

The second type of applets is those based on the Swing class JApplet. Swing applets use the Swing classes to provide the GUI. Swing offers a richer and often easier-to-use user interface than does the AWT. Thus, Swing-based applets are now the most popular. However, traditional AWT-based applets are still used, especially when only a very simple user interface is required. Thus, both AWT- and Swing-based applets are valid. As JApplet inherits Applet, all the features of Applet are also available in JApplet also.

Applet Basics

All applets are subclasses (either directly or indirectly) of Applet. Applets are not stand-alone programs. Instead, they run within either a web browser or an applet viewer. appletviewer is the standard applet viewer provided by the JDK.

Execution of an applet does not begin at main( ). Actually, few applets even have main( )methods. Instead, execution of an applet is started and controlled with an entirely different mechanism

Output to your applet’s window is not performed by System.out.println( ). Rather, in non-Swing applets, output is handled with various AWT methods, such as drawString( ).

Input is also handled differently than in a console application.

To use an applet, it is specified in an HTMLfile. One way to do this is by using the <APPLET> tag.

The applet will be executed by a Java-enabled web browser when it encounters the APPLET tag within the HTMLfile. An applet can be viewed and tested more conveniently using the appletviewer, by simply including a comment at the head of our Java source code file that contains the APPLET tag. E.g.

/*

<applet code="MyApplet" width=200 height=60>

</applet>

*/

This comment contains an APPLET tag that will run an applet called MyApplet in a window that is 200 pixels wide and 60 pixels high.

The HTML <APPLET> Tag

APPLET tag is used to start an applet from both an HTML document and from an applet viewer. An applet viewer will execute each APPLET tag that it finds in a separate window, while web browsers will allow many applets on a single page.

The syntax for a fuller form of the APPLET tag is shown here. Bracketed items are optional.

< APPLET

         [CODEBASE = codebaseURL]

         CODE = appletFile

         [ALT = alternateText]

         [NAME = appletInstanceName]

         WIDTH = pixels HEIGHT = pixels

         [ALIGN = alignment]

         [VSPACE = pixels] [HSPACE = pixels]

> 

[< PARAM NAME = AttributeName VALUE = AttributeValue>]

[< PARAM NAME = AttributeName2 VALUE = AttributeValue>]

. . .

[HTML Displayed in the absence of Java]

</APPLET>

Let’s take a look at each part now.

CODEBASE: CODEBASE is an optional attribute that specifies the base URL of the applet code, which is the directory that will be searched for the applet’s executable class file (specified by the CODE tag). The HTML document’s URL directory is used as the CODEBASE if this attribute is not specified.

CODE: CODE is a required attribute that gives the name of the file containing your applet’s compiled .class file. This file is relative to the code base URL of the applet, which is the directory that the HTML file was in or the directory indicated by CODEBASE if set.

ALT: The ALT tag is an optional attribute used to specify a short text message that should be displayed if the browser recognizes the APPLET tag but can’t currently run Java applets.

NAME: NAME is an optional attribute used to specify a name for the applet instance. Applets must be named in order for other applets on the same page to find them by name and communicate with them.

WIDTH and HEIGHT: WIDTH and HEIGHT are required attributes that give the size (in pixels) of the applet display area.

ALIGN: ALIGN is an optional attribute that specifies the alignment of the applet. This attribute is treated the same as the HTML IMG tag with these possible values: LEFT, RIGHT, TOP, BOTTOM, MIDDLE, BASELINE, TEXTTOP, ABSMIDDLE, and ABSBOTTOM.

VSPACE and HSPACE: These attributes are optional. VSPACE specifies the space, in pixels, above and below the applet. HSPACE specifies the space, in pixels, on each side of the applet.

PARAM NAME and VALUE: The PARAM tag allows you to specify applet-specific arguments in an HTML page. Applets access their attributes with the getParameter( ) method.

The Applet Class

Applet provides all necessary support for applet execution, such as starting and stopping. It also provides methods that load and display images, and methods that load and play audio clips. Applet extends the AWT class Panel. In turn, Panel extends Container, which extends Component. These classes provide support for Java’s window-based, graphical interface. Thus, Applet provides all of the necessary support for window-based activities. Following are the major methods defined by Applet class.

Method	Description
void init( )	Called when an applet begins execution. It is the first method called for any applet.
void start( )	Called by the browser when an applet should start (or resume) execution. It is automatically called after init( ) when an applet first begins.
void stop( )	Called by the browser to suspend execution of the applet. Once stopped, an applet is restarted when the browser calls start( ).
void destroy( )	Called by the browser just before an applet is terminated. Your applet will override this method if it needs to perform any cleanup prior to its destruction.
void showStatus(String str)	Displays str in the status window of the browser or applet viewer. If the browser does not support a status window, then no action takes place.
void resize(int width, int height)	Resizes the applet according to the dimensions specified by width and height.
boolean isActive( )	Returns true if the applet has been started. It returns false if the applet has been stopped.
String getParameter(String paramName)	Returns the parameter associated with paramName. null is returned if the specified parameter is not found.
URL getCodeBase( )	Returns the URL associated with the invoking applet.
URL getDocumentBase( )	Returns the URL of the HTML document that invokes the applet.
String getAppletInfo( )	Returns a string that describes the applet.

Applet Architecture

An applet is a window-based program. As such, its architecture is different from the console-based programs. The major features of an applet program are:

• Applets are event driven. An applet waits until an event occurs. The run-time system notifies the applet about an event by calling an event handler that has been provided by the applet. Once this happens, the applet must take appropriate action and then quickly return. Any applet should not enter a mode of operation in which it maintains control for an extended period.

•  The user initiates interaction with an applet. In console-based program, when the program needs input, it will prompt the user and then call some input method, such as readLine( ). This is not the way it works in an applet. Instead, the user interacts with the applet as he or she wants, when he or she wants. These interactions are sent to the applet as events to which the applet must respond. For example, when the user clicks the mouse inside the applet’s window, a mouse-clicked event is generated.

Applet Skeleton

Most applets override a set of methods that provides the basic mechanism by which the browser or applet viewer controls the execution of the applet. Four of these methods, init( ), start( ), stop( ), and destroy( ), apply to all applets and are defined by Applet class. Default implementations for all of these methods are provided. Applets do not need to override those methods they do not use.

AWT-based applets will also override the paint( ) method, which is defined by the AWT Component class. This method is called when the applet’s output must be redisplayed. These five methods can be assembled into the skeleton shown here:

FirstApplet.java

import java.awt.*;

import java.applet.*;

/*

<applet code="FirstApplet" width=300 height=100>

</applet>

*/

public class FirstApplet extends Applet {

         /* Called first. */

         public void init() {

                  // initialization

         }

         /* Called second, after init(). Also called whenever the applet is restarted. */

         public void start() {

                  // start or resume execution

         }

         /* Called when the applet is stopped. */

         public void stop() {

                  // suspends execution

         }

         /* Called when applet is terminated. This is the last method executed. */

         public void destroy() {

                  // perform shutdown activities

         }

         /* Called when an applet's window must be restored. */

         public void paint(Graphics g) {

                  // redisplay contents of window

         }

}

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. The second import statement imports the applet package, which contains the class Applet.

The <applet> tag given as comment is used by the applet viewer to display the applet.

Every applet that you create must be a subclass of Applet. So we define the class FirstApplet as a subclass of Applet. This class must be declared as public, because it will be accessed by code that is outside the program.

The above applet can be compiled as:

>javac FirstApplet.java

It can be run using applet viewer as

> appletviewer FirstApplet.java

The skeleton applet above does nothing, but displays the following applet.

Applet initialization and termination

It is important to understand the order in which the various methods shown in the skeleton are called. When an applet begins, the following methods are called, in this sequence:

1. init( )
2. start( )
3. paint( )

When an applet is terminated, the following sequence of method calls takes place:

1. stop( )
2. destroy( )

Let’s look more closely at these methods.

init( )

The init( ) method is the first method to be called. This is where we should initialize variables. This method is called only once during the life time of our applet.

start( )

The start( ) method is called after init( ). It is also called to restart an applet after it has been stopped. Whereas init( ) is called once, the first time an applet is loaded; start( ) is called each time an applet’s HTML document is displayed on the screen. So, if a user leaves a web page and comes back, the applet resumes execution at start( ).

paint( )

The paint( ) method is called each time your applet’s output must be redrawn. This situation can occur for several reasons. For example, the window in which the applet is running may go behind another window and then uncovered. Or the applet window may 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 will contain 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.

stop( )

The stop( ) method is called when a web browser leaves the HTML document containing the applet; E.g. when it goes to another page. When stop( ) is called, the applet is probably running. It suspend threads that don’t need to run when the applet is not visible. It can be restarted them when start( ) is called if the user returns to the page.

destroy( )

The destroy( ) method is called when the environment determines that your applet needs to be removed completely from memory. At this point all resources the applet was using must be freed. The stop( ) method is always called before destroy( ).

The life cycle of a typical applet can be depicted as shown below:

Simple Applet Display Methods

To display a string in an applet window we can use drawString( ) method, which is a member of the Graphics class. Typically, it is called from within either update( ) or paint( ).

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).

To set the background colour of an applet’s window the setBackground( ) method can be used. To set the foreground colour (e.g. the color in which text is shown), the setForeground( ) method can be used.

These methods are defined by Component, and they have the following general forms:

void setBackground(Color newColor)

void setForeground(Color newColor)

Here, newColor specifies the new colour.

Example:

setBackground(Color.green);

setForeground(Color.red);

The constants that can be used to specify colors, defined by the class Color are: Color.black, Color.magenta, Color.blue, Color.orange, Color.cyan, Color.pink, Color.darkGray, Color.red, Color.gray, Color.white, Color.green, Color.yellow, Color.lightGray

The background and fore ground colours can be changes any where according to the requirement, but a good place to do them is in the init() method.

the current settings for the background and foreground colours can be obtained by calling getBackground( ) and getForeground( ), respectively. They are also defined by Component. The signatures of the methods are as shown:

Color getBackground( )

Color getForeground( )

Requesting Repainting

An applet writes to its window only when its update( ) or paint( ) method is called by the AWT. One of the fundamental architectural constraints imposed on an applet is that it must quickly return control to the run-time system. It cannot create a loop inside paint( ) that repeatedly scrolls the banner, for example. This would prevent control from passing back to the AWT.

AWT defines the repaint( ) method to solve this issue. It causes the AWT run-time system to execute a call to your applet’s update( ) method, which, in its default implementation, calls paint( ). Thus, for another part of your applet to output to its window, simply store the output and then call repaint( ).

Two simple forms of repaint() are:

void repaint( )

which causes the entire window to be repainted and

void repaint(int left, int top, int width, int height)

which paints only the region specified by the arguments. This saves time, as painting the entire window is costly in terms of time.

Using the Status Window

In addition to displaying information in its window, an applet can also display a message to the status window of the browser or applet viewer on which it is running. To do so, the showStatus( ) method can be called passing the string to be displayed as an argument. It can be used for giving updates to user regarding what is happening, suggest options, report errors and for debugging.

The signature of the method is:

void showStatus(String message)

Example:

showStatus("This is the status window");

Passing Parameters to Applets

The <APPLET> tag in HTML allows us to pass parameters to our applet. To retrieve a parameter, the getParameter( ) method can be used. It returns the value of the specified parameter in the form of a String object.

Example: The following program demonstrates how parameters can be passed into an applet

/* <applet code = "AppletParam" height = "300" width = "500">

<param name = "Language" value ="Java">

<param name = "Creators" value ="Sun">

</applet>*/

import java.awt.*;

import java.applet.*;

public class AppletParam extends Applet{

public void init(){

setBackground(Color.white);

setForeground(Color.red);

}

public void paint(Graphics g){

String p1 = getParameter("Language");

String p2 = getParameter("Sun");

g.drawString("Language: "+p1,25, 75);

g.drawString("Creators: "+p2,25, 100);

}

}

The above program creates the following applet as the output

Java Script:Dialog Boxes and Prompts

Dialog Boxes and Prompts

Dialog boxes are used to raise an alert, or to get confirmation on any action or to take small amount of input from the users. JavaScript supports three important types of dialog boxes: The alert, confirm and prompt dialog boxes. These dialog boxes appear as separate windows and their content is independent from the text in html page and does not affect the content of the page. The three types of dialog boxes provided by JavaScript are:

Alert Dialog Box:

An alert dialog box is mostly used to give a warning message to the users. Like if one input field requires to enter some text but user does not enter that field then as a part of validation you can use alert box to give warning message. An alert dialog box is invoked using the alert() method, which takes a string as argument and displays it in the dialog box. In addition to the string, it also displays an OK button. Once the dialog box is displayed, the JavaScript and HTML code stops processing until the OK button is pressed.

Syntax:

alert(“<Message>”);

Example:

alert(“Welcome to my Webpage”);

Prompt Dialog Box:

The prompt dialog box is very useful when you want to pop-up a text box to get user input. Thus it enables you to interact with the user. The prompt() method instantiates the prompt dialog box. It displays a specified message and also provides a single data entry field, which accepts the user input.

The prompt() method takes two parameters (i) A label which you want to display in the text box (ii) A default string to display in the text box.

Syntax:

prompt(“<Message>”, “<Default text>”);

Example:

prompt(“Enter your favourite colour”, “Red”);

Prompt dialog box has two buttons: OK and Cancel. If the user clicks on OK button the prompt() will return entered value from the text box. If the user clicks on the Cancel prompt() returns null.

You can use prompt dialog box as follows:

Confirmation Dialog Box:

A confirmation dialog box is mostly used to take user's consent on any action. The confirm() method displays a dialog box with a predefined message and two buttons: OK and Cancel.

Syntax:

confirm(“<Message>”);

Example:

confirm(“Are you sure you want to quit?”);

If the user clicks on OK button the window method confirm() will return true. If the user clicks on the Cancel button confirm() returns false.

Programming in Java: Interfaces

Interfaces

Using the keyword interface, we can specify what a class must do, but not how it does it. Interfaces

are syntactically similar to classes, but they lack instance variables, and their methods are declared without any body. Once it is defined, any number of classes can implement an interface. Also, one class can implement any number of interfaces. So it is Java’s way of multiple inheritance.

To implement an interface, a class must create the complete set of methods defined by the interface. However, each class is free to determine the details of its own implementation.

Defining an Interface

An interface is defined much like a class. This is the general form of an interface:

access interface name {

return-type method-name1(parameter-list);

return-type method-name2(parameter-list);

type final-varname1 = value;

type final-varname2 = value;

// ...

return-type method-nameN(parameter-list);

type final-varnameN = value;

}

Notice that the methods that are declared have no bodies. They end with a semicolon after the parameter list. They are, essentially, abstract methods; there can be no default implementation of any method specified within an interface. Each class that includes an interface must implement all of the methods. Variables can be declared inside of interface declarations. They are implicitly final and static, meaning they cannot be changed by the implementing class.

Example

interface Area{

      double area();

      void displayArea();

}

Implementing Interfaces

Once an interface has been defined, one or more classes can implement that interface. To implement an interface, include the implements clause in a class definition, and then create the methods defined by the interface. The general form of a class that includes the implements clause looks like this:

class classname [extends superclass] [implements interface [,interface...]] {

// class-body

}

If a class implements more than one interface, the interfaces are separated with a comma.

Example

class Figure{

      int dim1, dim2;

      double ar;

}

class Circle extends Figure implements Area{

      public double area(){

                  return 3.14 * dim1 * dim1;

      }

      public void displayArea(){

                  System.out.println("Area of Circle: "+ar);

      }

      Circle(){

      }

      Circle(int r){

                  dim1 = r;

      }

}

class Rectangle extends Figure implements Area{

      public double area(){

                  return (double)dim1 * dim2;

      }

      public void displayArea(){

                  System.out.println("Area of Rectangle: "+ar);

      }

      Rectangle(){

      }

      Rectangle(int l, int b){

                  dim1 = l;

                  dim2 = b;

      }

}

public class IntTest{

      public static void main(String[] args){

                  Circle c1 = new Circle(10);

                  Rectangle r1 = new Rectangle(3,4);

                  c1.ar = c1.area();

                  r1.ar = r1.area();

                  c1.displayArea();

                  r1.displayArea();

      }

}

Here we have two classes Rectangle and Circle implementing the same interface Area. They also extends a class Figure. Both the classes provide implementations for the methods defined in Area, namely public double area()and public void displayArea(). This helps in bringing uniformity among all classes that implement Area.

Extending Interfaces

One interface can inherit another by use of the keyword extends. The syntax is the same as for inheriting classes. When a class implements an interface that inherits another interface, it must provide implementations for all methods defined within the interface inheritance chain.

Interface Interface1 extends Interface2{

      // body of Interface 1

}

Suppose a class implements Interface1, then it need to provide definition for all the methods in Interface1 as well as those in Interface2.

Interface Vs Abstract Class

Feature	Interface	Abstract class
Multiple inheritance	A class may inherit several interfaces.	A class may inherit only one abstract class.
Default implementation	An interface cannot provide any code, just the signature.	An abstract class can provide complete, default code and/or just the signature.
Access modifiers	An interface cannot have access modifiers for the functions, properties etc everything is assumed as public	An abstract class can contain access modifiers for the subs, functions, properties
Fields	If the interface contain any field, it is static and final by default	No such restriction
Instantiation	An Interface cannot be instantiated	An abstract class also cannot be instantiated