Class notes(week 10) on applet programming

of 13
Class Notes on Applet Programming (using swing) (Week - 10)
Contents: - Basics of applet programming, applet life cycle, difference between application & applet programming,
parameterpassinginappletinapplets,conceptof delegationeventmodel and listener, I/O in applets, use of repaint(),
getDocumentBase(),getCodeBase()methods,layoutmanager(basicconcept),creationof buttons(JButton class only) &
text fields.
Java applet
A Javaappletisa small applicationwritteninJava,anddeliveredto usersinthe formof bytecode.The userlaunchesthe
Java appletfroma web page. The Java applet then executes within a Java Virtual Machine (JVM) in a process separate
from the web browser itself, yet it can appear in a frame of the web page, in a new application window, or in Sun's
AppletViewer, a stand-alone tool for testing applets. Java applets were introduced in the first version of the Java
language in 1995.
What is an applet?
Applets are small applications that are accessed on an Internet server, transported over the Internet, automatically
installed,andrunas part of a Web document.Afteranappletarrivesonthe client,it has limited access to resources, so
that itcan produce an arbitrarymultimediauserinterfaceandruncomplex computations withoutintroducingthe riskof
viruses or breaching data integrity.
The simple applet
import java.awt.*;
import java.applet.*;
public class SimpleApplet extends Applet {
public void paint(Graphics g) {
g.drawString("A Simple Applet", 20, 20);
}
}
This applet begins with two import statements.
 The first imports the Abstract Window Toolkit (AWT) classes. Applets interact with the user through the AWT,
not throughthe console-basedI/Oclasses.The AWT contains support for a window-based, graphical interface.
As youmightexpect,the AWTisquite large and sophisticated,andacomplete discussionof it isoutof the scope
of this note. Fortunately, this simple applet makes very limited use of the AWT.

of 13
 The secondimportstatementimportsthe appletpackage,whichcontainsthe classApplet.Everyappletthat you
create must be a subclass of Applet.
The next line in the program declares the class SimpleApplet.
NOTE:-This class must be declared as public, because it will be accessed by code that is outside the program.
Inside SimpleApplet, paint( ) is declared. This method is defined by the AWT and must be overridden by the applet.
paint( ) is called each time that the applet must redisplay its output. This situation can occur for several reasons. For
example, the windowinwhichthe appletisrunningcan be overwrittenbyanotherwindowandthenuncovered.Or, the
appletwindowcanbe minimizedandthenrestored,paint() isalsocalled when the applet begins execution. Whatever
the cause,wheneverthe appletmustredrawitsoutput,paint( ) iscalled.The paint( ) methodhasone parameterof type
Graphics.Thisparametercontainsthe graphicscontext,whichdescribesthe graphicsenvironmentinwhichthe appletis
running. This context is used whenever output to the applet is required.
Inside paint( ) is a call to drawString( ), which is a member of the Graphics class. This method outputs a string
beginning at the specified X,Y location. It has the following general form:
void drawString(String message, int x, int y);
The co-ordinates system of computer graphics is shown below for your reference
Here,message isthe stringto be outputbeginningatx,y.Ina Java window,the upper-leftcorneris location 0,0. The call
to drawString( ) in the applet causes the message “A Simple Applet” to be displayed beginning at location 20,20.
Notice that the applet does not have a main( ) method. Unlike Java programs, applets do not begin execution at
main().Infact,most appletsdon’tevenhave amain( ) method. Instead, an applet begins execution when the name of
its class is passed to an applet viewer or to an Internet browser.
After you enter the source code for SimpleApplet, compile in the same way that you have been compiling programs.
However,runningSimpleAppletinvolvesadifferentprocess. Infact,there are two ways in which you can run an applet:
Executing the applet within a Java-compatible Web browser.
Using an applet viewer, such as the standard SDK tool, appletviewer. An applet viewer executes your applet in a
window. This is generally the fastest and easiest way to test your applet.

of 13
Each of these methods is described next.
To execute anappletinaWeb browser,youneedtowrite a short HTML text file that contains the appropriate APPLET
tag. Here is the HTML file that executes
SimpleApplet:
<applet code="SimpleApplet" width=200 height=60>
</applet>
The width and height statements specify the dimensions of the display area used by the applet. (The APPLET tag
contains several other options that are examined more closely later is this note.) After you create this file, you can
execute your browser and then load this file, which causes SimpleApplet to be executed.
To execute SimpleAppletwithanappletviewer,youmayalsoexecute the HTMLfile shown earlier. For example,
if the preceding HTML file is called RunApp.html, then the following command line will run SimpleApplet:
C:>appletviewer RunApp.html
However,amore convenientmethodexiststhatyoucan use to speeduptesting.Simplyincludea comment at the head
of yourJava source code file thatcontainsthe APPLETtag. By doingso,your code is documentedwithaprototype of the
necessaryHTML statements,andyoucan testyour compiledappletmerely by starting the appletviewer with your Java
source code file. If you use this method, the SimpleApplet source file looks like this:
import java.awt.*;
/*
<applet code="SimpleApplet" width=200 height=60>
</applet>
*/
public class SimpleApplet extends Applet {
public void paint(Graphics g) {
g.drawString("A Simple Applet", 20, 20);
}
}
In general,youcanquicklyiterate throughappletdevelopmentbyusingthese three steps:
 Edit a Java source file.
 Compile your program.
 Execute the appletviewer,specifyingthe name of yourapplet’ssource file.The appletviewerwill encounterthe
APPLET tag within the comment and execute your applet.
C:>appletviewer SimpleApplet.java
The window produced by SimpleApplet, as displayed by the applet viewer, is shown in the following illustration:

of 13
Here are the key points that you should remember now:
 Applets do not need a main( ) method.
 Applets must be run under an applet viewer or a Java-compatible browser.
 User I/Ois notaccomplishedwithJava’s stream I/O classes. Instead, applets use the interface provided by the
AWT.
The complete syntax of the <applet>tag is as follows:

of 13
Viewing Applets from a Web Browser
To make your applet accessible on the Web, you need to store the class file (say SampleApplet.class) and HTML
webpage (say DisplayApplet.html) on a Web server. You can view the applet from an appropriate URL.

of 13
Applications Vs. Applets
Feature Application Applet
main()
method
Present Notpresent
Execution RequiresJRE Requiresabrowserlike Chrome
Nature Calledasstand-alone applicationasapplicationcanbe
executedfromcommandprompt
Requiressome thirdpartytool help like a
browsertoexecute
Restrictions Can accessany data or software available onthe system cannot accessany thingon the system
exceptbrowser’sservices
Security Doesnot require anysecurity Requireshighestsecurityforthe systemas
theyare untrusted
Advantages of Applets
1. Executionof appletsiseasyina Webbrowseranddoesnot require anyinstallationordeploymentprocedure in
realtime programming(whereasservletsrequire).
2. Writingand displaying(justopeninginabrowser) graphicsand animationsiseasierthanapplications.

of 13
3. In GUI development,constructor,sizeof frame,windowclosingcode etc.are notrequired(butare requiredin
applications).
Restrictions of Applets
1. Applets are required separate compilation before opening in a browser.
2. In realtime environment, the bytecode of applet is to be downloaded from the server to the client machine.
3. Appletsare treatedas untrusted(as theywere developed by unknown people and placed on unknown servers
whose trustworthiness is not guaranteed) and for this reason they are not allowed, as a security measure, to
access any system resources like file system etc. available on the client system.
4. Extra Code is required to communicate between applets using AppletContext.
What Applet can't do – Security Limitations
Appletsare treatedas untrustedbecause theyare developed by somebody and placed on some unknown Web server.
Whendownloaded,theymayharmthe systemresourcesor steal passwords and valuable information available on the
system. As applets are untrusted, the browsers come with many security restrictions. Security policies are browser
dependent.Browserdoesnotallowthe applettoaccessany of the systemresources(appletispermittedtouse browser
resources, infact, applet execution goes within the browser only).
 Appletsare notpermittedtouse anysystemresourceslike file systemastheyare untrustedandcan injectvirus
intothe system.
 Appletscannotreadfromor write to hard diskfiles.
 Appletmethodscannotbe native.
 Appletsshouldnotattempttocreate socketconnections
 Appletscannotreadsystemproperties
 Appletscannotuse anysoftware availableonthe system(exceptbrowserexecutionarea)
 Cannotcreate objectsof applicationsavailable onthe systembycomposition
The JRE throws SecurityExceptionif the appletviolatesthe browserrestrictions.
What is delegation event model in java?
Eventmodel isbasedonthe concept of an 'EventSource' and 'EventListeners'.Anyobjectthatisinterested in receiving
messages (or events ) is called an Event Listener. Any object that generates these messages ( or events ) is called an
Event Source
Event Delegation Model is based on four concepts:
 The Event Classes
 The Event Listeners
 Explicit Event Enabling
 Adapters
The modernapproach to handlingeventsisbasedonthe delegationeventmodel,whichdefinesstandardandconsistent
mechanismstogenerate andprocessevents.Itsconceptisquite simple:asource generatesaneventandsendsitto one
or more listeners. In this scheme, the listener simply waits until it receives an event. Once received, the listener
processesthe eventandthenreturns.The advantage of thisdesignisthat the application logic that processes events is
cleanly separated from the user interface logic that generates those events. A user interface element is able to
"delegate"
the processing of an event to a separate piece of code.

of 13
Overview of the Delegation Event Model
 The 1.1 eventmodel isalsocalledthe "delegation"eventmodel because eventhandlingisdelegatedtodifferent
objectsandmethodsratherthan havingyourApplethandle all the events.
 The ideais that eventsare processedby eventlisteners,whichare separate objectsthathandle specifictypesof
events.
Note:Inorder to use the delegationeventmodel properly,the Appletshould notbe the listener.
 The listenerregistersandspecifieswhicheventsare of interest(forinstance mouseevents).
 Only those eventsthatare beinglistenedforwill be processed.
 Each differenteventtype usesaseparate Eventclass.
 Each differentkindof listeneralsousesaseparate class.
 Thismodel makeseventhandlingmore efficientbecausenotall eventshave to be processedandthe events
that are processedare onlysenttothe registeredlistenersratherthantoan entire hierarchyof eventhandlers.
 Thismodel alsoallowsyourApplettobe organizedsuchthatthe applicationcode andthe interface code (the
GUI) can be separated.
 Also,usingdifferenteventclassesallowsthe Javacompilertoperformmore specifictype errorchecking.
Event Listeners
An EventListener,once settoan appletobjectwaitsforsome actiontobe performedonit,be itmouse click,mouse
hover,pressingof keys,clickof button,etc.The classyouare using(e.g. JButton,etc.) reportsthe activityto a classset
by the classusingit.That methodthendecidesonhow toreact because of that action,usuallywithaseriesof if
statementstodeterminewhichactionitwasperformedon. source.getSource() will returnthe name of the object
that the eventwasperformedon,whilethe sourceisthe objectpassedtothe functionwhenthe actionisperformed.
Everysingle time the actionisperformed,itcallsthe method.
ActionListener
ActionListener is an interface that could be implemented in order to determine how certain event should be
handled. When implementing an interface, all methods in that interface should be implemented, ActionListener
interface has one method to implement named actionPerformed().
The followingexample showshowtoimplement ActionListener:
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
class ActionDemo extends JFrame implements ActionListener {
public ActionDemo() {
setDefaultCloseOperation(EXIT_ON_CLOSE);
setSize(300, 300);
getContentPane().setLayout(new FlowLayout());
JButton b = new JButton("Click me");
getContentPane().add(b);
b.addActionListener(this);
}
public void actionPerformed(ActionEvent e) {
JOptionPane.showMessageDialog(this, "Hi !!!");
}

of 13
public static void main(String[] args) {
new ActionDemo().setVisible(true);
}
}
Whenyoucompile andrun the above code,a message will appearwhenyouclickonthe button.
The repaint() method-The GUI (AWT) Thread
One of a numberof systemthreads.Thisthreadisresponsible foracceptinginputeventsandcallingthe paint() method.
The programmershould leavecalling paint() to thisthread. Java appletsrarelycall paint() directly.
There are two wayspaint() calls are generated:
1. spontaneouspainting,initiatedbythe environment
2. programmergeneratedcallsviarepaint() andupdate()
Spontaneouscalls
In the firstcase,spontaneouspaintingreferstocallstopaint() fromthe browser.
The GUI thread makes these calls. Every applet or application with a GUI (i.e., a Frame) has a GUI thread.
There are foursituationswhenthe GUIthreadcallspaint() spontaneously.
1. a windowiscoveredbyanotherandthenre-exposed.Paint() iscalledtoreconstructthe damagedpartsof the
uncoveredwindow
2. afterdeiconification
3. inan appletafterinit() hasfinished
4. whena browserreturnstoa page whichcontainsanapplet,providedthe appletisatleastpartiallyexposed.
Therepaint()Method
The secondcase,whenpaint() callsare generetediswhenthe programcallsrepaint() orupdate().The repaint() method
isthe one invokedbyaprogram to do drawing.Theirare 4 versionsof thismethodbutthe one withno argumentsis
usuallyused.Drawingviarepaint() mostoftentakesplace inresponse touserinput.
repaint() ==> update() ==(usuallycalls)==> paint()
repaint() doesnotinvoke paint() directly.It schedules a call to an intermediate method,update().Finally,update() calls
paint() (unlessyouoverrideupdate).

of 13
The reasonfor thiscomplexityisJava'ssupportforconcurrentprogramming.Itdoesthisusingthreads.
Usingrepaint()canbetricky foratleast three reasons.
1. the interactionbetweenrepaint()andthe spontaneouspaintingdone bythe GUIthread
2. the fact that repaint() justasksthe threadsystemtoschedule acall to update()/paint() andthenexits.The
repaint() methodis asynchronous.
3. the problemof preventingyourdrawingfrombeingerasedwhenbeingupdated.
All these potential complicationsare consideredindetailsbelow.
However,let'sstartwitha discussionwhathappensif paint() orupdate() are calleddirectly.
Using paint( ) and update() directly.
What isof concernhere iswhat happensif the user,forexample,coversall orpartof yourdrawingby anotherwindow,
and thenuncoversyourdrawingagain.Doesitsurvive?Similarly,whathappensif the userresizesthe browserwindow?
Whenpaint() is calledafterinit(),orafterthe applethasbeencoveredoriconified,itusesthe defaultpaint()whichjust
paintsthe background color,therebyerasingthe image.A paint() methodhasbeenadded.Thisworksbutthe method
paint() isoverlycomplex.
Thisis a simplerwaytodo it,because update() automaticallycoversthe drawingareawiththe backgroundcolour,
essentiallyanerasingoperation,andthen automaticallycallspaint().
Preventingerasingby update()
Why callingpaint()orupdate() directly isnot sucha goodidea
The paint() method is always called by the AWT main GUI thread. It is possible that other applets are also using that
thread. The environment also uses the thread to reconstruct components damaged by, for example, resizing or
overlayingoriconifying/ deiconifying. If you have a complex paint() method and call it directly you may tie everything
else up,therebydegradingperformance anddefeatingthe multitaskingnature of Java. A bug in your code may not only
stop you applet but everything else running on the page as well.
Usingupdate()directly creates thesameproblems.
The repaint() methodisdesignedtoavoidthese problems.Howeveritcanbe tricky to use as itwas mentionedbefore
The behaviour of repaint()
The behaviourof the followingexampleisslightlydifferentfromthe previousexamples,if youonlyconsiderthe applet
inisolation.Inparticular,itimplementsthe differentinterface: MouseMotionListenerinterface.Butthe maindifference
isthat this versionismore 'polite'thanthe others:itusesrepaint.
If repaint() isjustcalledbyuserinteractionswithcomponentsyoushouldhave noproblemsusingrepaint() thisway.
However,if repaint() iscalledinatightloop,the AWT threadqueue maybe overwhelmedandstrange thingsmay
happen.

of 13
repaint() merely requests the AWT thread to call update(). It then returns immediately. This type of behaviour
is called asynchronous. How the AWT thread reacts to the request is up to it. This behavour can lead to
problems if you are not careful:
Multiple repaint() requests can unintentionally be combined into one
The behavourwhichcausesthe mosttrouble isthe fact that the AWT may combinemultiplerapidfire repaint()
requests into one request.In practice thisbehaviouroftenmeansthatonlythe lastrepaint() requestinthe sequence
actuallycausesupdate() andpaint() tobe called.The resultisthatpart of your beautiful drawinggoesmissing.
This problem usually occurs when repaint() is being called from a program loop.
UsingThread.sleep()to slowdownrepaint()requests
On the otherhand,some textbooksrecommendthatyouuse the Thread.sleep() method.The ideaistoput,
try {
Thread.sleep(100);
}
catch(InterruptedException ex) {}
eitherjustbefore orjustafterthe repaint() call.The Thread.sleep(100) putsthe currentlyrunningthreadtosleepfor
100 milliseconds.Thisallowsotherthreads,if there are any,achance to run.
Whenonly the AWT thread is present
Thisdoesn'twork!Puttingthe AWT threadto sleepsolvesnothing.Nothinghappens,itwakesup,anotherrepaint()
requestcomesinbutthe AWT thread goesto sleepagain.Sothe pile upof requestsjustgetsfrozenforthe sleeptime.
In the endtheyare combinedthe same wayaswithout the sleepandyourdrawingisstill ruined.
In a multithreaded program
UsingThread.sleep() inaprogrammercreatedthreadtoslow downrapidfire repaint() callssolvesthe problemof
combinedrepaint() requests.The AWTGUI threadkeepsrunningandhastime to deal withrequeststoupdate() and
paint() because the threadwhichisthe source of the requestsisputto sleepperiodicallyandthussloweddown.The
AWT threadmeanwhilegoesonitsmerryway.
getDocumentBase
public URL getDocumentBase()
Gets the URL of the documentinwhichthisappletisembedded.Forexample,suppose anappletiscontained
withinthe document:
http://java.sun.com/products/jdk/1.2/index.html
The documentbase is:
http://java.sun.com/products/jdk/1.2/index.html
Returns: the URL of the documentthatcontainsthisapplet.

of 13
getCodeBase
public URL getCodeBase()
Gets the base URL. This isthe URL of the directorywhichcontainsthisapplet.
Returns:
the base URL of the directorywhichcontainsthisapplet.
Code for An applet program to give demo of getDocumentBase() and getCodeBase() methods in
Java
/* <applet code="URLDemo" height=100 width=400> </applet> */
import java.awt.*;
import java.net.*;
publicclass URLDemo extends Applet
{
publicvoid paint(Graphics g){
String msg;
URL url=getCodeBase();
msg = "Code Base : "+url.toString();
g.drawString(msg,10,20);
url=getDocumentBase();
msg="Document Base : "+url.toString();
g.drawString(msg,10,40);
}
}

Class notes(week 10) on applet programming

More Related Content

What's hot (20)

Similar to Class notes(week 10) on applet programming (20)

More from Kuntal Bhowmick (20)

Recently uploaded (20)

Class notes(week 10) on applet programming