Java and Web Design

Q.1 What are various parameters of an applet tag.

Answer:

The Applet tag is used to embed an applet in an HTML document the Applet tag takes
zero or more parameters.

The Applet Tag

The Applet tag is written the Body tag of an HTML document.

Syntax

<APPLET

CODE = “name of the class file that extends java.applet.Applet”

CODEBASE = “path of the class file “

HEIGHT = “maximum height of the applet, in pixels “

WIDTH = “maximum width of the applet, in pixels “

VSPACE = “vertical space between the applet and the rest of the HTML “

HSPACE = “horizontal space between the applet and the rest of the HTML “

ALIGN = “alignment of the applet with respect to the rest of the web page “

ALT = “alternate text to be displayed if the browser does not support applets “

>

<PARAM NAME=”parameter_name” value=”value_of_parameter”>

……..

</APPLET>

The most commonly used attributes of the Applet tag are CODE, HEIGHT, WIDTH,
CODEBASE and ALT. You can send parameters to the applet using the PARAM tag.
The PARAM tag must be written between <APPLET> and </APPLET>

Example

<Applet

Code = “clock. class”

MI0032 1
 Java and Web Design

Height = 200

Width = 200 >

</applet>

Life Cycle of an Applet

You can describe the life cycle of an applet through four methods. These methods are:

· The init () method.

· The start () method.

· The stop () method.

· The destroy () method.

The init ( ) method

The init () method is called the first time an applet is loaded into the memory of a
computer. You can initialize variables, and add components like buttons and check
boxes to the applet in the init () method.

The start ( ) method

The start () method is called immediately after the init () method and every time the
applet receives focus as a result of scrolling in the active window. You can use this
method when you want to restart a process, such as thread animation, every time the
applet receives the focus.

The stop ( ) method

The stop () method is called every time the applet loses the focus. You can use this
method to reset variables and stop the threads that are running.

The destroy ( ) method

The destroy ( ) method is called by the browser when the user moves to another page.
You can use this method to perform clean-up operations like closing a file.

The following diagram depicts the life cycle of an applet.

MI0032 2
 Java and Web Design

It is not mandatory to use any or all the methods of the applet. These methods are called
automatically by the Java environment, and hence, must be declared public. None of the
methods accept parameters. For example,

public void init ()

All but the most trivial applets override a set of methods that provides the basic
mechanism by which the browser or applet viewer interfaces to the applet and controls
its execution. Four of these methods–init( ), start( ), stop( ), and destroy( ) – are
defined by Applet. Another, paint( ), is defined by the AWT Component class. Default
implementations for all of these methods are provided. Applets do not need to override
those methods they do not use. However, only very simple applets will not need to
define all of them. These five methods can be assembled into the skeleton shown here:

// An Applet skeleton.

import java.awt.*;

import java.applet.*;

/*

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

</applet>

*/

public class AppletSkel extends Applet {

// Called first.

public void init() {

// initialization

MI0032 3
 Java and Web Design

/* 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

Q.2 Write a short note on following topic:

a. Knock Knock Protocol

b. Datagram

Answer: A

The KnockKnockProtocol class implements the protocol that the client and server use to
communicate. This class keeps track of where the client and the server are in their
conversation and serves up the server's response to the client's statements. The
KnockKnockServer object contains the text of all the jokes and makes sure that the
client gives the proper response to the server's statements. It wouldn't do to have the
client say "Dexter who?" when the server says "Knock! Knock!"

All client/server pairs must have some protocol by which they speak to each other;
otherwise, the data that passes back and forth would be meaningless. The protocol that
your own clients and servers use depends entirely on the communication required by
them to accomplish the task.

Answer: B

Clients and servers that communicate via a reliable channel, such as a TCP socket, have
a dedicated point-to-point channel between themselves, or at least the illusion of one. To
communicate, they establish a connection, transmit the data, and then close the

MI0032 4
 Java and Web Design

connection. All data sent over the channel is received in the same order in which it was
sent. This is guaranteed by the channel.

In contrast, applications that communicate via datagrams send and receive completely
independent packets of information. These clients and servers do not have and do not
need a dedicated point-to-point channel. The delivery of datagrams to their destinations
is not guaranteed. Nor is the order of their arrival.

Definition: A datagram is an independent, self-contained message sent over the

network whose arrival, arrival time, and content are not guaranteed.

The java.net package contains three classes to help you write Java programs that use
datagrams to send and receive packets over the network: DatagramSocket,
DatagramPacket, and MulticastSocketAn application can send and receive
DatagramPackets through a DatagramSocket. In addition, DatagramPackets can be
broadcast to multiple recipients all listening to a MulticastSocket.

Writing a Datagram Client and Server

The example featured in this section consists of two applications: a client and a server.
The server continuously receives datagram packets over a datagram socket. Each
datagram packet received by the server indicates a client request for a quotation. When
the server receives a datagram, it replies by sending a datagram packet that contains a
one-line "quote of the moment" back to the client.

The client application in this example is fairly simple. It sends a single datagram packet
to the server indicating that the client would like to receive a quote of the moment. The
client then waits for the server to send a datagram packet in response.

Two classes implement the server application: QuoteServer and QuoteServerThread. A

single class implements the client application: QuoteClient.

Let’s investigate these classes, starting with the class that contains the main method for
the server application. Working with a Server-Side Application contains an applet
version of the QuoteClient class.

The QuoteServer Class

The QuoteServer class, shown here in its entirety, contains a single method: the main
method for the quote server application. The main method simply creates a new
QuoteServerThread object and starts it:

import java.io.*;
public class QuoteServer {
public static void main(String[] args) throws IOException {
new QuoteServerThread().start();
}
}

The QuoteServerThread class implements the main logic of the quote server.

MI0032 5
 Java and Web Design

The QuoteServerThread Class

When created, the QuoteServerThread creates a DatagramSocket on port 4445

(arbitrarily chosen). This is the DatagramSocket through which the server
communicates with all of its clients.

public QuoteServerThread() throws IOException {

this("QuoteServer");
}
public QuoteServerThread(String name) throws IOException {
super(name);
socket = new DatagramSocket(4445);

try {
in = new BufferedReader(
new FileReader("one-liners.txt"));
} catch (FileNotFoundException e)
System.err.println("Couldn't open quote file. " +
"Serving time instead.");
}
}

Remember that certain ports are dedicated to well-known services and you cannot use
them. If you specify a port that is in use, the creation of the DatagramSocket will fail.

The constructor also opens a BufferedReader on a file named one-liners.txt which

contains a list of quotes. Each quote in the file is on a line by itself.

Now for the interesting part of the QuoteServerThread: its run method. The run method
overrides run in the Thread class and provides the implementation for the thread. For
information about threads, see Defining and Starting a Thread.

The run method contains a while loop that continues as long as there are more quotes in
the file. During each iteration of the loop, the thread waits for a DatagramPacket to
arrive over the DatagramSocket. The packet indicates a request from a client. In
response to the client’s request, the QuoteServerThread gets a quote from the file, puts it
in a DatagramPacket and sends it over the DatagramSocket to the client that asked for it.

Let’s look first at the section that receives the requests from clients:

byte[] buf = new byte[256];

DatagramPacket packet = new DatagramPacket(buf, buf.length);
socket.receive(packet);

The first statement creates an array of bytes which is then used to create a
DatagramPacket. The DatagramPacket will be used to receive a datagram from the
socket because of the constructor used to create it. This constructor requires only two
arguments: a byte array that contains client-specific data and the length of the byte
array. When constructing a DatagramPacket to send over the DatagramSocket, you also
must supply the Internet address and port number of the packet’s destination. You’ll see
this later when we discuss how the server responds to a client request.

MI0032 6
 Java and Web Design

The last statement in the previous code snippet receives a datagram from the socket (the
information received from the client gets copied into the packet). The receive method
waits forever until a packet is received. If no packet is received, the server makes no
further progress and just waits.

Now assume that, the server has received a request from a client for a quote. Now the
server must respond. This section of code in the run method constructs the response:

String dString = null;

if (in == null)
dString = new Date().toString();
else
dString = getNextQuote();
buf = dString.getBytes();

If the quote file did not get opened for some reason, then in equals null. If this is the
case, the quote server serves up the time of day instead. Otherwise, the quote server gets
the next quote from the already opened file. Finally, the code converts the string to an
array of bytes.

Now, the run method sends the response to the client over the DatagramSocket with this
code:

InetAddress address = packet.getAddress();

int port = packet.getPort();
packet = new DatagramPacket(buf, buf.length, address, port);
socket.send(packet);

The first two statements in this code segment get the Internet address and the port
number, respectively, from the datagram packet received from the client. The Internet
address and port number indicate where the datagram packet came from. This is where
the server must send its response. In this example, the byte array of the datagram packet
contains no relevant information. The arrival of the packet itself indicates a request from
a client that can be found at the Internet address and port number indicated in the
datagram packet.

The third statement creates a new DatagramPacket object intended for sending a
datagram message over the datagram socket. You can tell that the new DatagramPacket
is intended to send data over the socket because of the constructor used to create it. This
constructor requires four arguments. The first two arguments are the same required by
the constructor used to create receiving datagrams: a byte array containing the message
from the sender to the receiver and the length of this array. The next two arguments are
different: an Internet address and a port number. These two arguments are the complete
address of the destination of the datagram packet and must be supplied by the sender of
the datagram. The last line of code sends the DatagramPacket on its way.

When the server has read all the quotes from the quote file, the while loop terminates
and the run method cleans up:

socket.close();

The QuoteClient Class

MI0032 7
 Java and Web Design

The QuoteClient class implements a client application for the QuoteServer. This
application sends a request to the QuoteServer, waits for the response, and, when the
response is received, displays it to the standard output. Let’s look at the code in detail.

The QuoteClient class contains one method, the main method for the client application.
The top of the main method declares several local variables for its use:

int port;
InetAddress address;
DatagramSocket socket = null;
DatagramPacket packet;
byte[] sendBuf = new byte[256];

First, the main method processes the command-line arguments used to invoke the
QuoteClient application:

if (args.length != 1) {
System.out.println("Usage: java QuoteClient <hostname>");
return;
}

The QuoteClient application requires one command-line arguments: the name of the
machine on which the QuoteServer is running.

Next, the main method creates a DatagramSocket:

DatagramSocket socket = new DatagramSocket();

The client uses a constructor that does not require a port number. This constructor just
binds the DatagramSocket to any available local port. It doesn’t matter what port the
client is bound to because the DatagramPackets contain the addressing information. The
server gets the port number from the DatagramPackets and send its response to that port.

Next, the QuoteClient program sends a request to the server:

byte[ ] buf = new byte[256];

InetAddress address = InetAddress.getByName(args[0]);
DatagramPacket packet = new DatagramPacket(buf, buf.length,
address, 4445);
socket.send(packet);

The code segment gets the Internet address for the host named on the command line
(presumably the name of the machine on which the server is running). This InetAddress
and the port number 4445 (the port number that the server used to create its
DatagramSocket) are then used to create DatagramPacket destined for that Internet
address and port number. Therefore the DatagramPacket will be delivered to the quote
server.

Note that the code creates a DatagramPacket with an empty byte array. The byte array is
empty because this datagram packet is simply a request to the server for information.

MI0032 8
 Java and Web Design

All the server needs to know to send a response–the address and port number to which
reply–is automatically part of the packet.

Next, the client gets a response from the server and displays it:

packet = new DatagramPacket(buf, buf.length);

socket.receive(packet);
String received = new String(packet.getData(), 0, packet.getLength());
System.out.println("Quote of the Moment: " + received);

To get a response from the server, the client creates a "receive" packet and uses the
DatagramSocket receive method to receive the reply from the server. The receive
method waits until a datagram packet destined for the client comes through the socket.
Note that if the server’s reply is somehow lost, the client will wait forever because of
the no-guarantee policy of the datagram model. Normally, a client sets a timer so that it
doesn’t wait forever for a reply; if no reply arrives, the timer goes off and the client
retransmits.

When the client receives a reply from the server, the client uses the getData method to
retrieve that data from the packet. The client then converts the data to a string and
displays it.

Running the Server and Client

After you’ve successfully compiled the server and the client programs, you run them.
You have to run the server program first. Just use the Java interpreter and specify the
QuoteServer class name.

Once the server has started, you can run the client program. Remember to run the client
program with one command-line argument: the name of the host on which the
QuoteServer is running.

After the client sends a request and receives a response from the server, you should see
output similar to this:

Quote of the Moment:

Good programming is 99% sweat and 1% coffee.

Q.3 What are the different access specifiers in Java? How can we call a superclass
constructor? Explain with a suitable example.

Answer:

An access specifier determines which features of a class (the class itself, the data
members, and the methods) may be used by other classes. Java supports three access
specifiers.

• public.
• private.
• protected.

MI0032 9
 Java and Web Design

The public Access Specifiers

All classes except inner class (class within classes) can have the public access specifier.
You can use a public class, a data member, or a method from any object in any Java
program.

Example

public class publicclass

public int publicvaraible;

public void publicmethod ()

The private Access Specifier

Only objects of the same class can access a private variable or method. You can declare
only variables, methods, and inner classes as private.

Example

private int privatevariable;

The protected Access Specifier

The variables, methods, and inner classes that are declared protected are accessible to
the subclasses of the class in which they are declared.

Example

protected int protectedvariable;

Default Access

If you do not specify any of the above access specifiers, the scope is friendly. A class,
variable, or method that has friendly access is accessible to all the classes of a package.

Consider the following set of classes. Class Y and Z inherit from class X. Class Z
belongs to a package different than that of classes X and Y

MI0032 10
 Java and Web Design

A method accessMe () has been declared in class X. The following table shows you the
accessibility of the method accessMe () from classes Y and Z

Access Specifier Class Y Class Z

accessME ( ) is declaredAccessible, as Y is aAccessible, as Z is a subclass
as protected subclass (event if it is in another
package)
accessMe ( ) is declaredAccessible, as it is in theNot accessible, as it is not in
without an accesssame package the same package
specifier (friendly)

You can access a non-private variable or method using an object of the class as shown
below:

Someclass classobject = new someclass ();

classobject.publicvariable;

classobject.protectedmethod ();

Although a subclass includes all of the members of its superclass, it cannot access those
members of the superclass that have been declared as private. For example, consider
the following simple class hierarchy:

/* In a class hierarchy, private members remain

private to their class.

This program contains an error and will not

compile.

*/

// Create a superclass.

class A {

int i; // public by default

private int j; // private to A

MI0032 11
 Java and Web Design

void setij(int x, int y) {

i = x;

j = y;

// A’s j is not accessible here.

class B extends A {

int total;

void sum() {

total = i + j; // ERROR, j is not accessible here

class Access {

public static void main(String args[]) {

B subOb = new B();

subOb.setij(10, 12);

subOb.sum();

System.out.println("Total is " + subOb.total);

This program will not compile because the reference to j inside the sum( ) method of B
causes an access violation. Since j is declared as private, it is only accessible by other
members of its own class. Subclasses have no access to it.

Note: A class member that has been declared as private will remain private to its class.
It is not accessibl e by any code outside its class, including subclasses.

A Superclass Variable Can Reference a Subclass Object

MI0032 12
 Java and Web Design

A reference variable of a superclass can be assigned a reference to any subclass derived

from that superclass. You will find this aspect of inheritance quite useful in a variety of
situations. For example, consider the following:

class Ref Demo {

public static void main(String args[]) {

BoxWeight weightbox = new BoxWeight(3, 5, 7, 8.37);

Box plainbox = new Box();

double vol;

vol = weightbox.volume();

System.out.println("Volume of weightbox is " + vol);

System.out.println("Weight of weightbox is " +

weightbox.weight);

System.out.println();

// assign BoxWeight reference to Box reference

plainbox = weightbox;

vol = plainbox.volume(); // OK, volume() defined in Box

System.out.println("Volume of plainbox is " + vol);

/* The following statement is invalid because plainbox

does not define a weight member. */

// System.out.println("Weight of plainbox is " +

plainbox.weight);

Here, weightbox is a reference to BoxWeight objects, and plainbox is a reference to

Box objects. Since BoxWeight is a subclass of Box, it is permissible to assign plainbox
a reference to the weightbox object.

It is important to understand that it is the type of the reference variable – not the type of
the object that it refers to – that determines what members can be accessed. That is,

MI0032 13
 Java and Web Design

when a reference to a subclass object is assigned to a superclass reference variable, you

will have access only to those parts of the object defined by the superclass. This is why
plainbox can’t access weight even when it refers to a BoxWeight object. If you think
about it, this makes sense, because the superclass has no knowledge of what a subclass
adds to it. This is why the last line of code in the preceding fragment is commented out.
It is not possible for a Box reference to access the weight field, because it does not
define one.

Although the preceding may seem a bit esoteric, it has some important practical
applications – two of which are discussed later in this chapter.

Using super

In the preceding examples, classes derived from Box were not implemented as
efficiently or as robustly as they could have been. For example, the constructor for
BoxWeight explicitly initializes the width, height, and depth fields of Box( ). Not only
does this duplicate code found in its superclass, which is inefficient, but it implies that a
subclass must be granted access to these members. However, there will be times when
you will want to create a superclass that keeps the details of its implementation to itself
(that is, that keeps its data members private). In this case, there would be no way for a
subclass to directly access or initialize these variables on its own. Since encapsulation is
a primary attribute of OOP, it is not surprising that Java provides a solution to this
problem. Whenever a subclass needs to refer to its immediate superclass, it can do so by
use of the keyword super.

super has two general forms. The first calls the superclass’ constructor. The second is
used to access a member of the superclass that has been hidden by a member of a
subclass. Each use is examined here.

Using super to Call Superclass Constructors

A subclass can call a constructor method defined by its superclass by use of the
following form of super:

super(parameter-list);

Here, parameter-list specifies any parameters needed by the constructor in the

superclass. super( ) must always be the first statement executed inside a subclass’
constructor. To see how super( ) is used, consider this improved version of the
BoxWeight( ) class:

// BoxWeight now uses super to initialize its Box attributes.

class BoxWeight extends Box {

double weight; // weight of box

// initialize width, height, and depth using super()

BoxWeight(double w, double h, double d, double m) {

MI0032 14
 Java and Web Design

super(w, h, d); // call superclass constructor

weight = m;

Here, BoxWeight( ) calls super( ) with the parameters w, h, and d. This causes the
Box( ) constructor to be called, which initializes width, height, and depth using these
values. BoxWeight no longer initializes these values itself. It only needs to initialize the
value unique to it: weight. This leaves Box free to make these values private if desired.

In the preceding example, super( ) was called with three arguments. Since constructors
can be overloaded, super( ) can be called using any form defined by the superclass. The
constructor executed will be the one that matches the arguments. For example, here is a
complete implementation of BoxWeight that provides constructors for the various ways
that a box can be constructed. In each case, super( ) is called using the appropriate
arguments. Notice that width, height, and depth have been made private within Box.

// A complete implementation of BoxWeight.

class Box {

private double width;

private double height;

private double depth;

// construct clone of an object

Box(Box ob) { // pass object to constructor

width = ob.width;

height = ob.height;

depth = ob.depth;

// constructor used when all dimensions specified

Box(double w, double h, double d) {

width = w;

height = h;

MI0032 15
 Java and Web Design

depth = d;

// constructor used when no dimensions specified

Box() {

width = -1; // use -1 to indicate

height = -1; // an uninitialized

depth = -1; // box

// constructor used when cube is created

Box(double len) {

width = height = depth = len;

// compute and return volume

double volume() {

return width * height * depth;

// BoxWeight now fully implements all constructors.

class BoxWeight extends Box {

double weight; // weight of box

// construct clone of an object

BoxWeight(BoxWeight ob) { // pass object to constructor

super(ob);

weight = ob.weight;

MI0032 16
 Java and Web Design

// constructor when all parameters are specified

BoxWeight(double w, double h, double d, double m) {

super(w, h, d); // call superclass constructor

weight = m;

// default constructor

BoxWeight() {

super();

weight = -1;

// constructor used when cube is created

BoxWeight(double len, double m) {

super(len);

weight = m;

class DemoSuper {

public static void main(String args[]) {

BoxWeight mybox1 = new BoxWeight(10, 20, 15, 34.3);

BoxWeight mybox2 = new BoxWeight(2, 3, 4, 0.076);

BoxWeight mybox3 = new BoxWeight(); // default

BoxWeight mycube = new BoxWeight(3, 2);

BoxWeight myclone = new BoxWeight(mybox1);

double vol;

vol = mybox1.volume();

MI0032 17
 Java and Web Design

System.out.println("Volume of mybox1 is " + vol);

System.out.println("Weight of mybox1 is " + mybox1.weight);

System.out.println();

vol = mybox2.volume();

System.out.println("Volume of mybox2 is " + vol);

System.out.println("Weight of mybox2 is " + mybox2.weight);

System.out.println();

vol = mybox3.volume();

System.out.println("Volume of mybox3 is " + vol);

System.out.println("Weight of mybox3 is " + mybox3.weight);

System.out.println();

vol = myclone.volume();

System.out.println("Volume of myclone is " + vol);

System.out.println("Weight of myclone is " + myclone.weight);

System.out.println();

vol = mycube.volume();

System.out.println("Volume of mycube is " + vol);

System.out.println("Weight of mycube is " + mycube.weight);

System.out.println();

This program generates the following output:

Volume of mybox1 is 3000.0

Weight of mybox1 is 34.3

Volume of mybox2 is 24.0

MI0032 18
 Java and Web Design

Weight of mybox2 is 0.076

Volume of mybox3 is -1.0

Weight of mybox3 is -1.0

Volume of myclone is 3000.0

Weight of myclone is 34.3

Volume of mycube is 27.0

Weight of mycube is 2.0

Pay special attention to this constructor in BoxWeight( ):

// construct clone of an object

BoxWeight(BoxWeight ob) { // pass object to constructor

super(ob);

weight = ob.weight;

Notice that super( ) is called with an object of type BoxWeight – not of type Box. This
still invokes the constructor Box(Box ob). As mentioned earlier, a superclass variable
can be used to reference any object derived from that class. Thus, we are able to pass a
BoxWeight object to the Box constructor. Of course, Box only has knowledge of its
own members.

Let’s review the key concepts behind super( ). When a subclass calls super( ), it is
calling the constructor of its immediate superclass. Thus, super( ) always refers to the
superclass immediately above the calling class. This is true even in a multileveled
hierarchy. Also, super( ) must always be the first statement executed inside a subclass
constructor.

A Second Use for super

The second form of super acts somewhat like this, except that it always refers to the
superclass of the subclass in which it is used. This usage has the following general form:

super.member

Here, member can be either a method or an instance variable.

This second form of super is most applicable to situations in which member names of a
subclass hide members by the same name in the superclass. Consider this simple class
hierarchy:

MI0032 19
 Java and Web Design

// Using super to overcome name hiding.

class A {

int i;

// Create a subclass by extending class A.

class B extends A {

int i; // this i hides the i in A

B(int a, int b) {

super.i = a; // i in A

i = b; // i in B

void show() {

System.out.println("i in superclass: " + super.i);

System.out.println("i in subclass: " + i);

class UseSuper {

public static void main(String args[]) {

B subOb = new B(1, 2);

subOb.show();

This program displays the following:

i in superclass: 1

i in subclass: 2

MI0032 20
 Java and Web Design

Although the instance variable i in B hides the i in A, super allows access to the i
defined in the superclass. As you will see, super can also be used to call methods that
are hidden by a subclass.

(5) The abstract class

An abstract class defines common properties and behaviors of other classes. An abstract
class is used as a base class to derive specific classes of the same kind. It defines
properties common to the classes derived from it. The abstract keyword is used to
declare such a class. The classes declared using the abstract keyword cannot be
instantiated.

Syntax

abstract class <class_name>

You can also declare abstract methods. Abstract methods have public scope. The code
below declares an abstract method for the class shape.

abstract class shape

public abstract float calculateArea ();

The abstract method calculateArea (), given above, is inherited by the subclasses of the
shape class. The subclasses Rectangle, Circle and Hexagon implement this method in
different ways.

public class circle extends shape

float radius;

public float calculateArea ()

return radius*22/7;

MI0032 21
 Java and Web Design

In the above example, the calculateArea () method has been overridden in the circle
class. If the method is not overridden, the class will inherit the abstract method from the
parent class. Any class that has a abstract method is abstract. Hence, you would not be
able to create an object of the circle class. Therefore, it is necessary to override the
calculateArea () method in the circle class.

The final Keyword

A class called password authenticates user login. You do not want anybody to change
the functionality of the class by extending it. To prevent inheritance, use the final
modifier.

Example

final class password

You will also find final classes in JDK package. For example, the java.lang.String class
has been declared final. This is done for security reasons. It ensure that any method that
refers to the String class gets the actual String class and not a modified one.

MI0032 22