Practice English Speaking&Listening with: Lecture -29 Java Applets - Part:2

Difficulty: 0

In this lecture we shall be continuing with our discussion on Java applets. If you recall

in our earlier class we had mainly talked about the differences between Java applications

and Java applets and we had also looked at some of the examples how a Java applet can

written, how an applet can be included or embedded from within an HTML page. So today

the first thing that we look at is how to convert any arbitrary Java application to

Java applet? Now this issue is important because we had mentioned earlier that we have Java

applications which can be written to perform any arbitrary task, any sort of complex or

sophisticated animation which can be done using that program. But in order to be used

along with a web page in the internet scenario we need to convert that program into an applet

which can be linked and also downloaded along with an HTML document.

So let us see or look at this issue first. First thing to note is that it is not very

difficult. Rather it is straightforward to convert an application to an applet. We call

it graphical because most often than not we have graphical applications running on web

pages. So the application that we want to convert is most often a graphical application;

an application with graphics. Now the reason it is straightforward is that you know in

Java, the classes that we use from which the objects are derived they are all instantiated

or they are all inherited from other super classes or parent classes. Now in application

or applet the classes that are used by default. They all decent from the same parent class.

That is why the way they work, the way they function the methods they use they are somewhat

quite similar. So you need have to make much change or much modification to an application

to make it work as an applet. Specifically an Applet uses the applet class; an application

uses the frame class. Both of which decent from the parent class called Container. So

essentially what I have told that because of this we can use the same methods and we

use the same user interface component description in both the application and applet.

Let us now look specifically at the different steps we need to follow to carry out or affect

this conversion. First thing of course this I have already mentioned that in order to

convert an application to an applet you need to create an HTML file. Because an applet

has to reside along with an HTML document; from the HTML document you need to provide

a link to the applet which will be downloaded along with the HTML file. So the first thing

you need to do is to have an HTML file with an APPLET tag which will specify the name

of the applet byte code or the class file, the size of the applet window and other optional

attributes which we had mentioned in our last class. Secondly one characteristic of a Java

application is the existence of the main method.

Whenever you execute a Java application, by default it is the main method which executes

first; from the main methods you can call other methods. So in an application the main

method normally contains will contain some code to create a new frame object in which

the different graphical item or user interface components would be included. So it is the

main method which initializes the context under which the application has to run. But

in an applet the situation is slightly different. We do not exclusively call an applet just

like a Java application. So that there is no question of explicitly calling the main

method. Rather the creation of the applet and the initiation or the beginning of execution

is done automatically by the browser after the applet has been loaded successfully into

the browser.

So, whereas for an application you need to explicitly type in a command to run it. For

an applet it is automatic. It gets downloaded along with the HTML file and as soon as download

completes the applet gets initiated or executed immediately by the browser. This does need

any user intervention. The main method when it creates a new frame object it creates to,

it defines the frame size for the applet. However here also you need to specify the

size of the window in which the program has to run. But here this information is provided

by the WIDTH and the HEIGHT attributes which are present in the APPLET tag of the HTML

document. This need be specified within the applet the size.

Third. An applet is derived from the class Applet. An application is derived from the

frame. So when you are converting an application to an applet instead of deriving it from Frame

you need to derive it from the Applet class. Fourthly you need to replace the constructor

of the Java application with a method called init. Just to recall the constructor of a

Java class represents a method having the same name as the class which is executed by

default whenever an instance of that class is created. Whenever you create an object,

the constructor class or the constructor method is automatically invoked and it is the responsibility

of the constructor to make or create all the initializations before the other methods can

be invoked. So in a Java application you have the constructor in applet you have an equivalent

method called init. So the constructor function has to be replaced by a function called init.

So whatever initializations you need to do which we earlier within the constructor, now

it will go inside init.

So an applet when it executes whenever the browser will create the object after creation

the method will be automatically called. Next there is an issue regarding the layout manager.

While any Java program you write, whatever graphics you create, that is created based

on some library based on a layout manager. Java application by default BorderLayout manager

while applet use the FlowLayout manager. So if you had an application which was written

assuming the BorderLayout manager, when you convert it into an applet which by default

uses the FlowLayout manager, you will have to explicitly specify that well. You do not

use the default layout manager. But rather use the BorderLayout manager. This can be

done by explicitly including the following statement in init method setLayout new BorderLayout.

This will be overriding the default layout manager in the applet.

Applets have no concept of title bars. So if there are any setTitle calls in application,

just remove them. And lastly you import the library at the beginning

of the program to include methods that are applicable to applets.

Let us now look at an example which will illustrate the process of the conversion. Now the example

that we take is as follows. The Java program will be creating a set of menu buttons which

will be displayed inside a frame. The buttons will be labelled with different colors like

Red, Blue, Green and White. And the purpose of the button is that if you click a particular

button with a mouse the background color will get changed to that particular color. So this

is what the program is given to you. We will start with an application then we shall see

how the application can be converted into an applet. Let us look at the application


So an application name of the Java program or the Java class file here, we have assumed

to ButtonDemo. This extends Frame. So by default it is a Frame class from descends. This is

an example of the constructor object we had mentioned. So it is a method having the same

name as the class ButtonDemo. So whenever there a method with the name same as the name

of the class file, that is constructed or this is considered as the constructor and

whenever you are running the application, this method will be called first. So here

you see what is there in the button demonstration? First line there is a title Button Demonstration.

This will appear at the top. You create or specify layout manager FlowLayout manager.

You add four buttons on your screen, on your frame with labels Red, Blue, Green and White.

So this new button, this will be creating a new instance of a button with the label

Red and add will be creating that object button on the current frame being displayed. So this

is the constructor method.

Then comes the event handler. So this is a public Boolean handleEvent. This is an event

handler method. So if you are closing the window, this will generate the WINDOW DESTROY

method. So this event handler simply says if the event die, if the id of the event v

dot id is this, Event.WINDOWDESTROYER which is the type, then you exit with an exit code

of zero. Otherwise if it is some other event you return to super.handleEvent, that means

you are recursively calling the parent object from where this object was derived? So that

you are saying that I will not handle the event myself. I will leave it to my parent

to handle it. And this method action by default is called whenever some kind of an event or

an action takes place. Like for example I am pressing the mouse button. So I want whenever

I click on one of the buttons of the mouse, I need to change the color.

So it is this action method which will be invoked whenever I press the mouse button.

Here if you look at the function it, takes as argument the Event and which Object was

clicked or on which Object this Event took place. But is the type of object, you check

if the idea or name of the object. This you can check using the equals function if. But

dot equals Red is true which means you have clicked the Red button, then you call the

method setBackground with, you set the color attribute to red. Else if you click

Blue then you set it to blue and so on. So if it is none of the valid buttons some other

then you return false. Repaint is a function which will allow you to refresh the window

so that whatever color you have selected the window will get refreshed with the new color

so that the changed color in the background will be reflected immediately.

So this is how the application will look like. And finally you have the main method which

simply creates frame ButtonDemo is the name of the class. It specifies the size of the

frame 300 by 300 and show is a method which is called to actually display. The Java application

on the created frame. So now the Java application is starting when you are invoking the method,

show actually the Java program starts running. This is how the application is now we want

to convert this application into an applet. Let us see.

So after conversion, the applet version looks like this. The first thing I told, we have

added this line import at the beginning. The name of applet you have

given as ColorApplet. Now instead of the constructor method we have given or we have created a

method called init which consists mainly the same set of statements which are there in

the constructor of the application, four buttons are created. Only thing was that you explicitly

set the layout manger here. This is what is done here.

The event handler and action they are same. There is no change out here. These methods

are already existing in the object of the class from where a frame or an applet is derived.

So you need have to change the event handler or action methods at all. They will remain

the same. The only change is that you do not add any title to it.

So now let us look at something called Applet Life Cycle. We have seen how an applet can

be written and applet can be created. Starting from a Java application which perhaps is something

which you have written to start with from an application. How to convert it to an applet?

We have specified the different steps to be followed also illustrated the process with

the help of a simple example. But even if it is some more complex example, you should

be following more or less the same sequence of steps. Now let us look at some very specify

methods that pertain to an applet. Only these are applet specify methods.

Now applet is supposed to be displayed as part of a browser. So there are certain events

which are specifically, you can say relevant with respect to the browser. Like I can close

a browser, I can open a browser; I can put one window on top of another window. So when

I am closing the browser. Do I need to still continue running the applet or I should suspend

the applet? Let it come up into my view again and it will again be started. So these are

some issues and these leads to some different states of an applet and so called applet life

cycle. So let us look at this so called applet life cycle now.

So when you are writing an applet as I had said there are methods that belong to the

applet class which are already there by default. We sometimes write our own methods with the

same names. That means we are overriding the existing methods. Now when you override the

method, for example, there may be a method already existing called paint or repaint.

I am writing the paint method again explicitly. So when I write I should be very clear about

the side effects. If I change or modify an existing method which was there as part the

derived class, what are the side effects I can expect to encounter. So the possible side

effects I should know. I should know when the methods are invoked and what kind of codes

should be placed in which method. Because I told in an applet there several types of

standard methods available and each of the methods have a specific purpose. So unless

you when they are called, why they are called? You will not be able to clearly tell that

which code has to be put inside which method.

So let us look at the methods first which applet specific. Now in the example that we

have seen we have already seen the init method. And we had told or mentioned that the init

method is invoked whenever the applet is started. Whenever the applet is executed on by browser

for the first time. So all the initializations that the applet requires with respect to the

window, with respect to color everything, with respect to the buttons and the other

GUI components you need, they will all have to be done by the init method. This init method

you should understand, this is called only once when the applet is loaded. So whatever

code you should put inside init, it should the code which is executed only once at the

beginning and not executed anytime in the future.

This you should understand. There is another method called start. The method start is invoked

after you invoke init. So this method is either invoked after init. Or as the starting point

or the resumption point of an applet after it was stopped and you want to restart it

again. So a typically situation when this might happen is this. Suppose I was displaying

an applet as part of a page web page on the browser. In the mean time I type in some URL

and I go to some other page or I click a link and go to some other page. So now the applet

is no more on the page. Now again from that new page I can press back, I can come back

to my original page which contains the applet.

So now the applet has to be resumed. So it is at this point we can invoke the start method

again. So the start method is invoked, every time we want to resume execution of the applet.

So simplistically speaking, every time the applet window is refreshed or the code is

displayed on the screen you have to invoke start. Say if a window was closed you are

opening again. So again the code has to be displayed. You are going to some page; you

are coming back to the page again. Then also you need to display. So under this situation

where you need to display the HTML document again, so under these circumstances the start

method will be invoked.

There is a method called paint. This will be called every time the window is damaged.

So if you put one window on top of the applet window, again remove it bring it on top. So

the other window is damaged. The paint will be called which will be refreshing the window.

And update is a similar function method which first fills the window with the background

color and then calls paint. So normally you would be calling update it, will first initializing

initialize the window with the default background color. Then it will refresh the graphics which

is there using the method paint. Stop is a method which is used to temporarily stop the

applet from running. This is typically called when the browser moves to some other document.

Suppose you type some other URL or click a link as I had said and some other document

is displayed on the browser. So during this time, there is no point in continuing to run

the applet which may be an animation applet. Animation thread which is a time consuming

activity, it will be consuming CPU time. So if the applet at all is not visible to us.

There is no point in continue running the applet there by consuming CPU time. Rather

you suspend or stop the applet till it becomes visible again. So stop is used to temporarily

suspend the applet. Now these activities can be restarted if we invoke start method again

in the future.

And finally destroy is a method which is called, when you want to permanently remove the applet

from the memory. Permanently remove means whatever resources the applet might be using

including memory they will all be removed or relinquished. Now this destroy can be called

when you are using the closing the browser window all together. Or if the applet itself

there is an explicit button to close this application. Close this program if you click

it. Then the destroy method will be invoked and applet will be removed from the memory

totally. So these are the different methods and just what I said.

If you look at this diagram, this diagram summarises the same thing. The circular nodes

are the states of an applet and each edge or the state transition is labelled by a method.

So from the beginning whenever the applet starts the init method is invoked. So the

applets start from the initialization state to an initialized state. Then the start method

is invoked. Now the applet is running here. Now at this point, if you invoke stop, then

it goes towards suspended state. From this suspended state, if you invoke start again

it comes back to the active state. If you call destroy then the applet is removed from

the memory. This is the terminate state and if while executing somehow the window gets

damaged you go to a temporarily state which means active but damaged.

So whenever the window becomes prominent again you have to call update to initialize the

background color. Then to call paint to redraw the objects which are present in the window

again. So this simple state transition diagram summarizes the life cycle of an applet. What

are the methods which can cause state transition? What are the typically functions of this method

and when they are called? So with this understanding you will be in a position to know what piece

of code should be included or put inside which part the applet.

Now let us look at the situation when we want to put multiple applets on the same page.

Now earlier we have said that it is indeed possible to put more than one application

in the same page. It is also possible for them to communicate among themselves. One

applet can send some data to the other applet can send or can call a method and so on. Let

us see through a simple example how this can be done.

As I had said a HTML page can have more than one applet. Now we typically would want these

applets to interact among themselves. Which means one applet may have access to the public

variables and methods of the other applets. How we do this? We do this by invoking a method

called getAppletContext which gives us a mean which gives the applet a mean to communicate

with the browser. The browser will actually return when you make a call to this and object

of type AppletContext which actually is a pointer or a means to access the other applet

you wanted. From one applet, you can make a call to this method. You get an object of

AppletContext type using which you can access the methods and the variables of the other


Now this you can do by using the NAME tag in the HTML document when you are including

the applet. So the getApplet method of the AppletContext, also we shall see an example

that how we can refer to an applet like this. But the constraint is that you can only carry

out this kind of communication between applets on the same page. One applet located on one

page cannot communicate with another applet on different web page. This is a constraint

you will have to remember.

All write the example that we look at is this. There are two applets we consider. One is

with a name GUI.class and other with a name compute.class. These two applets have been

assigned the names first and second in the HTML file using the name attribute. The GUI

class is what it does is it actually reads in the amount of money in Rupees. So by default

it reads in a value which indicates the money in Rupees. And it also reads in a currency

type dollar, euro or something else. The compute.class will actually read whatever data was fed in

the GUI class including the amount and currency type and will contain a method called convert

which will convert Rupee into the currency of the type specified. So the idea is like

this. One applet simply allows the user to type in the amount in Rupees and currency

type. The other has a method which can convert into the currency type specified. So the first

applet will be calling the second applet with the parameters the user has entered and the

result that is coming back will be used to display the result back on the screen. This

is what this example will do.

First let us look at the HTML file. So the TITLE is currency conversion demo. There are

two applets the first applet GUI class, the NAME that we have given is first. Some WIDTH

and HEIGHT of this applet given. The second applet is not actually meant to be displayed

on the screen that so the HEIGHT as a token WIDTH and HEIGHT are given small numbers 10

by 10, Compute.class the NAME is given as second. This is just a dummy example so no

other HTML code is there. Now let us see what is there in the do Java program GUI class

and Compute class.

This is the applet. In the applet, what we have is this. First we have

the init method. Now in the init method we create a new panel. On the panel we set the

layout manager to FlowLayout. Then we add a little a label to the panel Rupees. Just

alongside this we add a text field of size 8 and add the text field to the panel. Secondly

we add another label called currency and another text field where the new currency is to be

typed in. Here the default WIDTH is 10. This also we add. So there are two, you can say

two form elements have been added in one of which I will be typing in an amount in the

other I will be typing in the new currency name dollar or whatever.

And then another field I am adding, this is the result; Result of conversion. So here

the text field I am assuming of size 50. This also we are adding and all these panels you

are adding to the bottom of the panel south. Now the Event handler is similar to the example

we had shown earlier. So nothing to say here.

And whenever some action takes place, whenever you click on something on the convert, then

this method gets to execute. Here you see what we are doing, r.getText. This we are

storing to x. If you go back you see the labels that you create the first label where you

are typing in the Rupee, the name of the text window is r. So here we write r.getText. So

we read the contents of that particular field store it into x after converting to integer,

ASCII to integer conversion. String y equal to nc, getText in the other field nc it is

already a string it is the currency type dollar baht. Or whatever I am typing there, so that

as a string we are storing in x and here in the third line we are invoking a particular

method of the other applet. So first we are getting an applet context; compute is the

name of the second.

So we are creating an object of type compute. We are calling the getContext object. The

getApplet method of that with the name of the second applet as parameter. So it returns

a pointer to the second applet p. Now we can call. Here you see p.convert, x y we can now

call the convert method of the second applet with the parameters x and y and the third

panel element here which is result we are setting the result setText to a value. First

the Rupee value r getText will trim any spaces will be trimmed deleted concatenant to Rupees

equal to; you convert it plus, the amount you have typed in the nc part. So in this

way you can actually, so you will be showing here as 1000 Rupees equal to say 25 dollars.

Something like this will be displayed and r nc are private fields which are not to be

accessed from outside.

Now the other applet the looks like this. Where in the init function, it

simply creates a panel, creates some labels. All these are optional. You can omit all these

things because the second applet does not really require any kind of graphics. This

is TextField result. All these are again optional, these are not needed.

What is needed is this method called convert. It takes two parameters. If the currency type

equals, this string dollar then say you divide rupee by 45 and return it. If it equals the

Thailand currency baht. Then you divide by1.2or if it equals any other currency

xyz. You make the appropriate calculation. So in this way through if an if then else

you can carry out any arbitrary currency conversion based whatever currency type you have typed

in. So this simple example shows you how one applet can call some method of another applet,

passing some arguments and getting the back the returned result and using it for some

subsequent calculation.

So let us look at some more examples of applets. Some very specific things we first look at

how we can image files from an applet. Because this is something which is quite popularly

used we often find or see an op applet where some kind of a photo album is being shown

cyclically automatically. So how we go on changing the image being displayed on the

screen from a Java program applet. Let us see that.

Now when you are trying to display an image or an applet, first thing is that you need

to access the image file. So the image file you can retrieve using the getImage method.

Now the getImage method has two forms where you directly specify the URL, where you can

get an image file specified by the URL. Secondly you give a relative path and the URL is subsequent

to that string path. So the second form will be using this string to provide a path relative

to the URL. For example in the URL path you give HTTP is the string path

portion you give slash docx slash images slash a.jpg. So you can separate these two components

out of an URL. So as to make your program look more structured instead of typing a very

long URLs every time. So a typically use will be like this because the advantage is

that this URL a need not be typed every time because if you call the method getDocumentBase

then by default it will return the Base URL of the current document. So the string path

can be specified like this, images slash logo.gif with respect to the Base Document. So this

is a typical use of this function.

Now here we show an example where two images are displayed alternately in response to some

window event. Now window event means some event that is occurring on the window. So

either where are clicking the mouse on the window or we are closing a window opening

it again. So suppose initially, this on the window, the image 1 was displayed, I close,

open it again; I see that now image tool is displayed. I close and open again. Again I

see image 1 is displayed. So this will continue happening. So first the HTML file. Here in

the HTML file you see here I have the APPLET the NAME of the code ImageView.class size

I have specified the size will be approximately equal to size of the Image and the two image

files are specified as parameters. So in order to make the applet program general these parameters

are passed from HTML. So for the first one, the NAME of the parameter is M1 and value

is face1.gif, for the second one, NAME is M2 and file NAME is face 2.gif.

Now let us look at the actual code. The code fairly simple. This is the class ImageView.

So here we have Boolean flag which we have initializing it to true. This flag actually

indicates that which of the two images will be displayed. The way the program is written

is that if flag is true, then one image will be displayed. If flag is false, then the other

image will be displayed. So flag is a Boolean variable which is used to keep track of the

fact that which image is to be displayed next. So x and y are two variables of type image.

This is the init method. This gets executed only once. So in this example what needs to

be done exactly once is to get the two image files get access to the image files.

So you call this get image function with getDocumentBase. And if you look at the previous page in the

PARAM with NAME M1, I am assigning the file name face one.gif. This is the parameter value.

So here I am calling the get parameter method to retrieve the value of this parameter which

will be face1.gif. Similarly in the second one it will be face2 gif. The two files we

have specified, you actually open the two images and assigning it to variables x and

y. This x and y are variables of type image. So in the init method we are actually opening

two image objects assigning one of them to x and other to y. This is what we are doing


Here this is the paint. So every time the window gets destroyed and it comes up, we

need to call paint. So every time you close the window and open it again, this is a window

event. Here this paint method will be called. So let us see what we are doing in paint.

In paint, we are comparing that Boolean variable flag. If it is true, then we are drawing x

using the draw image method. Parameters are x the name of the image objects the coordinate

0, 0 from where in the window the image has to be displayed. And this represents in which

frame or window this means the current one. And we made flag to call separate so that

next time when you come you go to else part. Similarly the else part you are displaying

the image y and the then you are flag to true. So as this example shows you see this example

also that if flag is true you come here this x. If flag is false you come here display


So every time the window is closed you open it again the method paint gets invoked and

alternately once the image x other time image y would be displayed cyclically. So this is

what we wanted. That, two images they will be displaying simul means display alternately.

So this program you can generalize to handle any number of events. Any number of images

which will be displayed one after the other or any particular order. Delay maybe different,

whatever you can do using Java you can implement here. You can use some functions where you

can specify the delays. All these things can be done.

Lastly we will look at an example where we will show how we can include audio clips inside

a Java applet. This is another which we require or use, quite often as part of Java applet

which shows attractive web pages. So there are methods again existing for this.

There is method called getAudioClip using which you can retrieve or audio object from

a specified file specified URL. So just like image there are two alternate forms. The first

form, you can specify the URL directly. In the second form, you can specify the base

URL and the path relative to the base URL just like the image case. You have this getAudioClip

method which you will invoke in one of these two ways.

To play the audio clip you have loaded, you can use the play method. Play method again

has two parameters. You can either specify play URL or play URL. The base URL and the

String path. Of course another form is there which I have not shown here you can call play

without any parameter. This third form will by default play the audio image which was

loaded previously using this getAudioClip method. So if you already have loaded a particular

audio clip using getAudioClip you can just call plat subsequently. So the last audio

clip loaded would get played by default or you can specify the clip id as a parameter.

Some typical usages of the play function or as follows. Here you can either say, here

the first one, you create a variable of type audio clip and you get an audio clip by calling

this method getAudioClip with a call to the getDocumentBase which gives the base URL and

the relative path you get And then with this returned variable object you call

play Anthem and then dot play. So the last one will start playing or you can directly

invoke play also getDocumentBase and So in either of these two approaches you can

play audio clips. Now in this same way we have just shown a couple of examples to show

that from a Java when you are designing an applet, it is rather easy to include images

audio clips as examples. Now in an applet which is supposed to be there as part of a

web page.

These kinds of requirements are essential because they help you in designing very attractive

web pages with multimedia contents. So in general you can have other kinds of contents

also. Like you can have an mpeg video clip; you can have a streaming video clip; you can

have any kind of content you can think of. Provided the appropriate library is available

to you, which you can include as an object and you can call the methods of that object

to load it to play it in whatever way you want. For example if you consider a video

clip then the methods that may be present under them would not only just be play. It

can be fast forward rewind position to a particular point, stop, pause, all these things. So all

these methods will be very much media dependent and Java actually has full support for almost

all kinds of media that are intended to be included as part of web pages.

So it helps you in designing web pages in a very convenient way. Now in our next lecture

we shall be continuing our discussion and we shall show that how Java also can be used

very easily for developing network applications. We shall see that how easy it is to write

client-side programs in Java. You can write a Java client, you can write a Java server,

they can be applets. One of them can be an applet; other can be a Java program running

on the server. They can communicate among themselves and the amount of additional lines

of code you need to write. For this is very small compared to an equivalent code you write

in a language like C or C plus plus say for example. So Java is also very suitable for

network or internet programming. This we shall see in our next class. So with this we come

to the end of whatever we had to discuss today. So now let us look at some of the solutions

to the questions we posed in our last class.

The first question was: Why do we consider Java to be secure?

Now this we had already mentioned in your last class. I am again repeating because this

is very important concept to understand. Java programs are downloaded from some other web

site and we would expect that when you are downloading and running them on my client

machine. The Java program should not do any kind of harm or should not be able to retrieve

any sensitive information that might be present on my local file system. So Java programs

typically are not allowed to invoke any local executable. They are not allowed to access

the local file system. They can communicate with only the web server from where the Java

program was downloaded. They cannot communicate with any other server and moreover since they

have do not have access to the local file system they cannot access any sensitive information

that are present on the local file system. Like for example user name email address or

any other such information which are very personal centric which we do not want to share

with others on the internet.

What makes Java programs platform independent? Now this we had mentioned that basically the

presence of the Java runtime or the Java Virtual Machine helps in making Java programs platform

independent. Because Java programs are compiled into a platform independent byte code format.

Byte code format is platform independent. You can freely copy them, you can freely download

them over the internet byte code is the same on all machines. But it is the Java Virtual

Machine which has to be there on your machine to make your machine Java ready or Java enabled.

So if you have the JVM installed on your machine. You can download Java byte codes and run them

on you are machine. And as I had said JVM or the Java runtime exist today on almost

all computing platforms that are in existence.

What is difference between Java byte code and Java runtime?

Java byte code is actually that intermediate code. This is the machine code of that hypothetical

machine which is generated by the j compiler. On the other hand, Java runtime is the interpreter

which executes the byte code.

What is the difference between a Java application and a Java applet?

This we have said repeatedly. Java application is a standalone program which typically is

executed in a standalone fashion where as an applet is linked to a web page it cannot

execute independently. It gets executed along with the web site in which it is executed

along with the web page. So the web page comes along with the Java. Java applet which gets

displayed along with the surrounding HTML code.

How can you pass parameters to an applet from the HTML page?

This we shall, we have seen already through examples that we can use the PARAM tag with

the NAME and VALUE attributes to pass the parameters and the parameters can accessed

by invoking the getParameter method.

Lastly, is it possible to invoke a method of some other applet from another applet on

the same page? Yes we have looked an example we had seen that we can use the getApplet

method to do so. The example which was discussed today illustrates this in detail. So now questions

from todays lecture.

Why do we need to sometime convert a Java application into an applet?

What is the purpose of the init method? What is the purpose of the start method?

What is the purpose of the paint method? How can an applet A invoke a method of applet

B where both A and B are included in the same HTML page?

How do you change the displayed image on an applet?

So as I had said, in our next lecture we shall be continuing our discussion on Java programming

with special emphasis on how to write or create client-side applications using Java. Till

then, good bye.

The Description of Lecture -29 Java Applets - Part:2