Java Applets - Bhecker.com

buninnateSoftware and s/w Development

Nov 18, 2013 (3 years and 6 months ago)

97 views

Java Overview

Java Overview



Design goals & features


platform independence, portable, secure, simple, object
-
oriented, …



Programming models


applications vs. applets vs. servlets


intro to applets


libraries, comments, classes, inheritance


applet tag in HTML


applet parameters

Java was developed at Sun Microsystems, 1995


originally designed for small, embedded systems in electronic appliances


initial attempts used C++, but frustration at limitations/pitfalls


recall: C++ = C + OOP features

the desire for backward compatibility led to the retention of many bad features


Java

desired features (from the Java white paper):

simple

object
-
oriented


robust

platform independent

architecture neutral

portable

dynamic

interpreted


high
-
performance

distributed

multi
-
threaded


secure


note: these are desirable features for any modern language


thus, Java has become very popular, especially when Internet related


also, Sun distributes free compilers (JDK) and open source

Language features

simple


syntax is based on C++ (familiarity


easier transition for programmers)


removed many confusing and/or rarely
-
used features

e.g., explicit pointers, operator overloading, automatic coercions


added memory management (reference count/garbage collection hybrid)

object
-
oriented


OOP facilities similar C++, all methods are dynamically bound


pure OOP


everything is a class, no independent functions*

robust


lack of pointers and memory management avoids many headaches/errors


libraries of useful, tested classes increases level of abstraction


arrays & strings are ADTs, well
-
defined interfaces

Language features (cont.)

platform independence


want to be able to run Java code on multiple platforms


neutrality is achieved by mixing compilation & interpretation

1.
Java programs are translated into
byte code

by a Java compiler


byte code is a generic machine code

2.
byte code is then executed by an interpreter (Java Virtual Machine)


must have a byte code interpreter for each hardware platform



an Applet is a special form of Java application


byte code is downloaded with page, JVM is embedded in browser

portable


byte code will run on any version of the Java Virtual Machine (JVM)

architecture
-
neutral


no implementation dependent features


e.g., sizes of primitive types is set (unlike C++)

Language features (cont.)

interpreted


needed for platform independence


interpreted


faster code
-
test
-
debug cycle, better run
-
time error checking

dynamic


JVM links classes at run
-
time as they are needed


if supporting class is recompiled, don’t have to recompile entire project

high
-
performance


faster than traditional interpretation since byte code is "close" to native code


still somewhat slower than a compiled language (e.g., C++)


Language features (cont.)

secure


Java applications do not have direct access to memory locations


memory accesses are virtual, mapped by JVM to physical locations


downloaded applets cannot open, read, or write local files


JVM also verifies authenticity of classes as they are loaded


Sun claim: execution model enables virus
-
free*, tamper
-
free* systems

distributed


extensive libraries for coping with TCP/IP protocols like HTTP & FTP


Java applications can access remote URL's the same as local files

multi
-
threaded


a
thread

is like a separate program, executing concurrently


can write Java programs that deal with many tasks at once by defining multiple
threads (same shared memory, but semi
-
independent execution)


threads are important for multi
-
media, Web applications

Java programming models

Java
applications

are stand
-
alone programs


must be compiled into Java byte code by Java compiler, then distributed


executed by an interpreter (Java Virtual Machine)



Java
applets

provide for client
-
side programming


compiled into Java byte code, then
downloaded as part of a Web page


executed by the JVM
embedded within the Web browser



unlike JavaScript, Java is full
-
featured with extensive library support


Java and its APIs have become industry standards


the language definition is controlled by Sun, ensures compatibility


Applications Programming Interfaces standardize the behavior of useful classes
and libraries of routines


Java
servlets

provide similar capabilities on the server
-
side


alternative to CGI programs, more fully integrated into Web server

important point: Java applets & applications look different!


if you want to define a stand
-
alone application, make an application

requires
public static void main

function, similar to C++ main


if you want to embed the code in a Web page, make an applet

requires
public void paint
,
public void init
, …


can define dual
-
purpose programs, but tricky

Java applets

as with JavaScript, security is central


when a Java applet is downloaded, the bytecode verifier of the JVM verifies to see if
it contains bytecodes that open, read, write to local disk


a Java applet can open a new window but they have Java logo to prevent them from
being disguised as system window (for stealing password)


a Java applet is not allowed to connect back to other servers except the host



this secure execution environment is called
sand box model

First Java applet

import java.awt.*;

import java.applet.*;


/**


* This class displays "Hello world!" on the applet window.


*/

public class HelloWorld extends Applet

{


public void paint(Graphics g)


{



g.drawString("Hello world!", 10, 10); // writes starting 10 pixels over & down


}

}

libraries

Java provides extensive library support in the form of classes


libraries are loaded using

import (
similar to
#include

in C++)



java.awt:

contains Abstract Window Toolkit (for GUI classes & routines)

java.applet:

contains the applet class definition

First Java applet

import java.awt.*;

import java.applet.*;


/**


* This class displays "Hello world!" on the applet window.


*/

public class HelloWorld extends Applet

{


public void paint(Graphics g)


{



g.drawString("Hello world!", 10, 10); // writes starting 10 pixels over & down


}

}

comments in Java

//


and

/* . . . */

work the same as in C++

/** . . . */

designate documentation comments



can be used to automatically generate HTML documentation (javadoc)

First Java applet

import java.awt.*;

import java.applet.*;


/**


* This class displays "Hello world!" on the applet window.


*/

public class HelloWorld extends Applet

{


public void paint(Graphics g)


{



g.drawString("Hello world!", 10, 10); // writes starting 10 pixels over & down


}

}

class definitions in Java


similar to C++ (but no semi
-
colon at end)

can contain instance variables (data fields) & methods(member functions)

precede class & method definitions with
public

to make available to all programs


there are no stand
-
alone functions in Java*


must be stored in a file of same name with .java extension

e.g.,

HelloWorld.java

First Java applet

import java.awt.*;

import java.applet.*;


/**


* This class displays "Hello world!" on the applet window.


*/

public class HelloWorld
extends Applet

{


public void paint(Graphics g)


{



g.drawString("Hello world!", 10, 10); // writes starting 10 pixels over & down


}

}

all applets inherit from the Applet class (in java.applet)

default methods include:


init():

called when page is loaded to create/initialize variables

by default, does nothing


paint(Graphics g):

called to draw (after init) or redraw (after being obscured)

here, the paint method is overridden to display text on the applet window

Embedding an applet in HTML

<html>

<!
--

Hello1.html
--
>


<head>


<title>Hello World Page</title>

</head>


<body>


<p>


<applet code="HelloWorld.class" height=100 width=100>


You must use a Java
-
enabled browser to view this applet.


</applet>

</p>


</body>

</html>

to include an applet in a Web page, use either


APPLET tag (deprecated)

CODE specifies applet name, HEIGHT and WIDTH specify window size

text between the APPLET tags is displayed if unable to execute (e.g., Java not enabled)


OBJECT tag

preferred for HTML 4, but not universally supported

HTML & applets

<html>

<!
--

Hello2.html
--
>


<head>


<title>Hello World Page</title>

</head>


<body>


<p>

<div align="center">

<table border=1>

<tr><td>


<applet code="HelloWorld.class" height=200 width=200>


You must use a Java
-
enabled browser to view this applet.

</applet>


</td></tr>

</table>

</div>

</p>


</body>

</html>

an applet can be
embedded within HTML
elements just like any
other element


useful for formatting and
layout

Parameters in HTML

<html>

<!
--

Hello3.html
--
>


<head>

<title>Hello World Page</title>

</head>


<body>


<p>

<div align="center">

<table border=1>

<tr><td>


<applet code="HelloWorld1.class" height=35 width=300>


<param name="name" value="Chris">


<param name="age" value=20>


You must use a Java
-
enabled browser to view this applet.

</applet>


</td></tr>

</table>

</div>

</p>


</body>

</html>

can specify parameters
to the APPLET when it
is embedded in HTML



each parameter must
have its own PARAM tag
inside the APPLET
element



specifies parameter
name and value

Applet parameters

import java.awt.*;

import java.applet.*;


/**


* This class displays a message based on parameters.


*/

public class HelloWorld1 extends Applet

{


public void paint(Graphics g)


{



String userName = getParameter("name");


int userAge = Integer.parseInt(getParameter("age"));




String message1 = "Hello " + userName + ".";



String message2 = "On your next birthday, you will be " +


(userAge+1) + " years old.";






g.drawString(message1, 10, 10);



g.drawString(message2, 10, 30);


}

}

can access parameters passed in from the HTML document

getParameter

accesses the value of the parameter (must know its name)


if the parameter represents a number, must

parseInt
or

parseFloat

Java vs. C++

in Java, every variable & method belongs to a class


as in C++, by default each object has its own copies of data fields

thus, known as
instance variables



as in C++, a variables declared
static

are shared by all class objects

thus, known as
class variables


similarly, can have a static method (
class method
)

can only operate on class variables, accessible from the class itself


class Math

{


public static final double PI = 3.14159;


// access as Math.PI


public static double sqrt(double num) { . . . }

// access as in Math.sqrt(9.0)


. . .

}

Primitive vs. reference types

primitive types are handled exactly as in C++


space for a primitive object is implicitly allocated


variable refers to the actual data (stored on the stack)

reference types (classes) are handled differently


space for a reference object must be explicitly allocated using
new


variable refers to a pointer to the data (which is stored in the heap)


Note: unlike with C++, programmer is not responsible for deleting dynamic objects

JVM performs automatic garbage collection to reclaim unused memory

Java only provides by
-
value parameter passing


but reference objects are implemented as pointers to dynamic memory


resulting behavior mimics by
-
reference


public void Init(int[] nums)

{


for (int i = 0; i < nums.length; i++) {


nums[i] = 0;


}

}

_____________________________





_


int nums[] = new int[10];

Init(nums);

Java libraries

String class
(automatically loaded from
java.lang
)

int length()

char charAt(index)

int indexOf(substring)

String substring(start, end)

String toUpperCase()

boolean equals(Object)

...


Array class
(automatically loaded from
java.lang
)

int length

instance variable

Type [](index)

operator

String toString()

...


Java provides extensive libraries of data structures & algorithms

java.util



Vector


Stack


LinkedList





Dictionary

HashTable

Random






Calendar


String str = "foo"

String str = new String("foo");

int[] nums = {1,2,3,4,5};

int[] nums = new int[10];

Java & inheritance

Java does NOT have templates*


generic functions/classes are obtained via
inheritance
(e.g,
Applet
)


with inheritance, can derive a new class from an existing class


automatically inherit attributes & methods of the parent class


object of derived class can be used wherever parent object is expected




every reference type is implicitly derived from the
Object

class



by defining data structures that contain
Object
s, any reference type can be stored
(and even mixed)


Stack things = new Stack();


String str = "foobar";

things.push(str);




// pushes String as an Object


Calendar today = Calendar.getDate();

things.push(today);



// pushes Calendar as an Object






Calendar value1 = (Calendar)things.pop(); // pops & coerces

String value2 = (String)things.pop(); // pops & coerces

Hello again

import java.awt.*;

import java.applet.*;

import java.util.Random;


/**


* This class displays lots of "Hello world!"s on the applet window.


*/

public class HelloWorld1 extends Applet

{


private static final int NUM_WORDS=100;


private static Random randy;




private int randomInRange(int low, int high)


{



return (Math.abs(
randy.nextInt()
) % (high
-
low+1)) + low;


}




public void init()


{



randy = new Random();


}




public void paint(Graphics g)


{



for (int i = 0; i < NUM_WORDS; i++) {



int x = randomInRange(1, 200);



int y = randomInRange(1, 200);



g.drawString("Hello world!", x, y);



}


}

}

can override init method to
allocate & initialize (similar
to a constructor)

Random class provides
methods for generating
random values

<applet code="HelloWorld1.class" height=200 width=200>


You must use a Java
-
enabled browser to view this applet.

</applet>

Applet behavior

recall


the init method is called when the applet is first loaded

useful for initializing variables & objects



the paint method is called immediately after init, and whenever the applet needs to
be redrawn (e.g., after window resized or obscured)

when paint is called, it is given the default Graphics object



Graphics methods include



void drawString(String msg, int x, int y)



void setColor(Color color)


Color
class is predefined, constants include:


Color.red, Color.blue, Color.black,
. . .


A colorful hello

import java.awt.*;

import java.applet.*;

import java.util.Random;


/**


* This class displays lots of "Hello world!"s on the applet window.


*/

public class HelloWorld2 extends Applet

{


private static final int NUM_WORDS=100;


private static final Color[] colors =



{Color.black,Color.red,Color.blue,Color.green,Color.yellow};


private static Random randy;




private int RandomInRange(int low, int high)


{



return (Math.abs(randy.nextInt()) % (high
-
low+1)) + low;


}




public void init()


{



randy = new Random();


}




public void paint(Graphics g)


{



for (int i = 0; i < NUM_WORDS; i++) {




int x = RandomInRange(1,
140
);




int y = RandomInRange(10, 200);




g.setColor(colors[RandomInRange(0,4)]);




g.drawString("Hello world!", x, y);



}


}

}

can store possible
colors in an array


change drawing color
using the

setColor

method

<applet code="HelloWorld2.class" height=200 width=200>

You must use a Java
-
enabled browser to view this applet.

</applet>

Parameters & applet dimensions

recall:


can specify parameters in the HTML document using
<PARAM>

tags


access the parameter values (based on name) using
getParameter

method

can also access the dimensions of an applet using a Dimension object



Dimension dim = getSize(); // stores applet dimensions



can then access applet height via

dim.height



can then access applet width via

dim.width


Adaptive hello

import java.awt.*;

import java.applet.*;

import java.util.Random;


/**


* This class displays lots of "Hello world!"s on the applet window.


*/

public class HelloWorld3 extends Applet

{


private static final Color[] colors =



{Color.black,Color.red,Color.blue,Color.green,Color.yellow};


private static Random randy;


private Dimension dim;


private int numReps;




private int RandomInRange(int low, int high)


{



return (Math.abs(randy.nextInt()) % (high
-
low+1)) + low;


}




public void init()


{



randy = new Random();



dim = getSize();



numReps = Integer.parseInt(getParameter("reps"));


}




public void paint(Graphics g)


{



for (int i = 0; i <
numReps
; i++) {




int x = RandomInRange(1,
dim.width
-
65);




int y = RandomInRange(10,
dim.height
);




g.setColor(colors[RandomInRange(0,4)]);




g.drawString("Hello world!", x, y);



}


}

}

getParameter

accesses the values of
the parameters


here, specify number of
reps in Web page

uses

getSize
to
get dimensions, pick
random coords for text
within the applet

<applet code="HelloWorld3.class" height=300 width=400>


<param name="reps" value=200>


You must use a Java
-
enabled browser to view this applet.

</applet>

Applet graphics

in addition to displaying text


can also draw figures on a Graphics object


void drawLine(int x1, int y1, int x2, int y2)


void drawRect(int x, int y, int width, int height)

void fillRect(int x, int y, int width, int height)


void drawOval(int x, int y, int width, int height)

void fillOval(int x, int y, int width, int height)




EXAMPLE: draw a red circle inscribed in a square, then draw random dots
(dart pricks)


by counting the number of dots inside vs. outside the circle, can estimate the value
of
p






p

= 4 * (area of circle/area of square)

Graphical applet

public class Monte1 extends Applet

{


private static Random randy;


private int NUM_POINTS;


private int SIZE;




private int RandomInRange(int low, int high) {
CODE OMITTED

}


private double distance(int x1, int y1, int x2, int y2) {
CODE OMITTED

}





public void init()


{



randy = new Random();



NUM_POINTS = Integer.parseInt(getParameter("points"));



Dimension dim = getSize();



SIZE = Math.min(dim.width, dim.height);


}




public void paint(Graphics g)


{



g.setColor(Color.red);



g.fillOval(0, 0, SIZE, SIZE);



for (int i = 0; i < NUM_POINTS; i++) {



int x = RandomInRange(0, SIZE);



int y = RandomInRange(0, SIZE);



if (distance(x, y, SIZE/2, SIZE/2) < SIZE/2) {



g.setColor(Color.white);



}



else {



g.setColor(Color.black);



}



g.drawLine(x, y, x, y);



}


}

}

<applet code="Monte1.class" height=300 width=300>


<param name="points" value=20000>


You must use a Java
-
enabled browser...

</applet>

init

method creates random
number generator & gets
parameters




paint

method draws a circle
and a bunch of random points

Double buffering

note: paint is called every time the page is brought to the front


in current version of Monte, this means new dots are drawn each time the page is
obscured and then brought back to the front


wastes time redrawing


dots are different each time the applet is redrawn




the double buffering approach works by keeping an off
-
screen image


in the init method (which is called when the page loads):

draw the figures on a separate, off
-
screen Graphics object


in the paint method (which is called whenever the page is brought forward):

simply display the off
-
screen image on the screen



Buffered applet

public class Monte2 extends Applet

{


. . .


private Image offScreenImage;


private Graphics offScreenGraphics;


. . .


public void init()


{



randy = new Random();



NUM_POINTS = Integer.parseInt(getParameter("points"));



Dimension dim = getSize();



SIZE = Math.min(dim.width, dim.height);






offScreenImage = createImage(SIZE, SIZE);



offScreenGraphics = offScreenImage.getGraphics();






offScreenGraphics
.setColor(Color.red);



offScreenGraphics
.fillOval(0, 0, SIZE, SIZE);



for (int i = 0; i < NUM_POINTS; i++) {



int x = RandomInRange(0, SIZE);



int y = RandomInRange(0, SIZE);



if (distance(x, y, SIZE/2, SIZE/2) < SIZE/2) {



offScreenGraphics
.setColor(Color.white);



}



else {



offScreenGraphics
.setColor(Color.black);



}



offScreenGraphics
.drawLine(x, y, x, y);



}


}




public void paint(Graphics g)


{



g.drawImage(offScreenImage, 0, 0, null);


}

}

<applet code="Monte2.class" height=300 width=300>


<param name="points" value=20000>


You must use a Java
-
enabled browser...

</applet>

init

method is called when
page is loaded


does drawing to a separate,
off
-
screen Graphics object


paint

is called after

init

and whenever the applet is
revisited


Note: don’t see image in
progress

Better buffering

public class Monte3 extends Applet

{


. . .



public void init() {


randy = new Random();


NUM_POINTS = Integer.parseInt(getParameter("points"));


Dimension dim = getSize();


SIZE = Math.min(dim.width, dim.height);


}



public void paint(Graphics g) {


if (offScreenImage == null) {


offScreenImage = createImage(SIZE, SIZE);



offScreenGraphics = offScreenImage.getGraphics();







offScreenGraphics.setColor(Color.red);


g.setColor(Color.red);



offScreenGraphics.fillOval(0, 0, SIZE, SIZE);


g.fillOval(0, 0, SIZE, SIZE);


for (int i = 0; i < NUM_POINTS; i++) {


int x = randomInRange(0, SIZE);


int y = randomInRange(0, SIZE);


if (distance(x, y, SIZE/2, SIZE/2) < SIZE/2) {


offScreenGraphics.setColor(Color.white);


g.setColor(Color.white);


}


else {


offScreenGraphics.setColor(Color.black);


g.setColor(Color.black);


}


offScreenGraphics.drawLine(x, y, x, y);


g.drawLine(x, y, x, y);


}


}


else {


g.drawImage(offScreenImage, 0, 0, null);


}


}

}

if want to see image as it is
drawn, must be done in

paint



when first loaded, have

paint

draw on the graphics
screen and also to an off
-
screen buffer


on subsequent repaints,
simply redraw the contents of
the off
-
screen buffer

<applet code="Monte3.class" height=300 width=300>


<param name="points" value=20000>

</applet>

GUI elements in applets

Java has extensive library support for GUIs (Graphical User Interfaces)


has elements corresponding to HTML buttons, text boxes, text areas, …



each element must be created and explicitly added to the applet


nameLabel = new Label("User's name");

add(nameLabel);


nameField = new TextField(20);

nameField.setValue("Dave Reed");

add(nameField);



by default, GUI elements are placed in the order they were added, with
elements moved to the next line as needed to fit


Text boxes

public class Monte4 extends Applet

{


. . .


private Label insideLabel;


private TextField insideField;


private Label outsideLabel;


private TextField outsideField;


. . .



public void init()


{


randy = new Random();


NUM_POINTS =


Integer.parseInt(getParameter("points"));


Dimension dim = getSize();


SIZE = Math.min(dim.width, dim.height);





insideLabel = new Label("Inside:");


add(insideLabel);


insideField = new TextField(6);


add(insideField);





outsideLabel = new Label("Outside:");


add(outsideLabel);


outsideField = new TextField(6);


add(outsideField);

}


public void paint(Graphics g)


{


. . .



insideField.setText("0");


outsideField.setText("0");




. . .




if (distance(x, y, SIZE/2, SIZE/2) < SIZE/2) {



g.setColor(Color.white);



int value =


Integer.parseInt(insideField.getText())+1;



insideField.setText(""+value);



}



else {



g.setColor(Color.black);



int value =


Integer.parseInt(outsideField.getText())+1;



outsideField.setText(""+value);



}



. . .


}

}

<applet code="Monte4.class" height=300 width=300>


<param name="points" value=20000>

</applet>

GUI layout

public class Monte5 extends Applet

{


. . .




public void init()


{


randy = new Random();


NUM_POINTS = Integer.parseInt(getParameter("points"));


Dimension dim = getSize();


SIZE = Math.min(dim.width, dim.height);





setLayout(new BorderLayout());





Panel p = new Panel();


insideLabel = new Label("Inside:");


p.add(insideLabel);


insideField = new TextField(5);


p.add(insideField);


outsideLabel = new Label("Outside:");


p.add(outsideLabel);


outsideField = new TextField(5);


p.add(outsideField);





add(p, BorderLayout.SOUTH);


}



. . .

}

Java provides several classes
for controlling layout


FlowLayout
is default


BorderLayout

allows
placement of elements around
the borders of the applet
screen


a

Panel

can contain
numerous elements

<applet code="Monte5.class" height=300 width=300>


<param name="points" value=20000>

</applet>

Event handling

in order to handle events (e.g., text changes, button clicks), can use the
event delegation model



must specify that the class implements the
ActionListener
interface


public class Monte6 extends Applet implements ActionListener



each source of events must be registered within the applet


dotButton = new Button("Click to generate dots");

dotButton.addActionListener();



must have an
actionPerformed
method to handle events


public void actionPerformed(ActionEvent e)

{


if (e.getSource() == dotButton) {


drawDots();


}

}

ActionListener

import java.awt.*;

import java.applet.*;

import java.awt.event.*;

import java.util.Random;


public class Monte6 extends Applet


implements ActionListener

{


. . .


private Button dotButton;



public void init()


{


randy = new Random();


NUM_POINTS =


Integer.parseInt(getParameter("points"));


Dimension dim = getSize();


SIZE = dim.width;





setLayout(new BorderLayout());


dotButton =


new Button("Click to generate dots");


dotButton.addActionListener(this);


add(dotButton, BorderLayout.SOUTH);



drawCircle();


}




public void drawCircle()


{



CODE FOR DRAWING CIRCLE


}



public void drawDots()


{


drawCircle();



Graphics g = getGraphics();


for (int i = 0; i < NUM_POINTS; i++) {


CODE FOR DRAWING DOTS


}


}




public void paint(Graphics g)


{


g.drawImage(offScreenImage, 0, 0, null);


}



public void actionPerformed(ActionEvent e)


{


if (e.getSource() == dotButton) {


drawDots();


}


}

}

<applet code="Monte6.class" height=300 width=300>


<param name="points" value=20000>

</applet>

Applet examples

The Java Boutique has lots of sample applets with source code



Graphing Calculator



Mandlebrot Set



Email front
-
end



Web search front
-
end



Java Tetris


Combining Java & JavaScript




integrating Java with JavaScript


calling Java routines from JavaScript


controlling an applet from JavaScript


accessing JavaScript & HTML elements from an applet



related topics


JavaBeans, Java archives (JARs)


recall: JavaScript is very good for simple tasks, GUI layout


flexible data typing, primitive object types fine for quick development


integration with HTML makes layout & control of GUI elements easy



not much library support, only primitive data structuring capabilities


not well
-
suited to multi
-
file projects, OO approach

JavaScript vs. Java

recall: Java is better at complex tasks, especially graphics


full
-
featured, more robust, extensive libraries of classes/routines


can support large projects, interacting objects



GUI layout is difficult, integration with HTML not obvious

IDEAL: make use of the the strengths of each language


include applets in a page when needed (e.g., graphics)


allow communication between applet & JavaScript code

Calling Java routines from JavaScript

<html>

<!
--

Note: works in Netscape only.
--
>


<head>


<title>Java+JavaScript Demo</title>

</head>


<body>


<script language="JavaScript">


document.write(
java.lang.Math.random()
);


</script>

</body>

</html>

Netscape Communicator allows direct calls to Java routines


specify full package name of routine, then call as in Java

useful for more esoteric routines that are not supported directly in JavaScript


this feature is NOT supported by Internet Explorer

Calling applet methods

more commonly, want to include an applet in a page,


control via HTML events & JavaScript




want to draw dots inside a square (with an inscribed circle)


could build GUI interface into applet, but required tricky layout manager



instead, leave graphics up to the applet, controlled via JavaScript

to call a Java applet method from JavaScript


document.
appletName
.
methodCall(…)


MontePI revisited

import java.awt.*;

import java.applet.*;

import java.util.Random;


public class Monte7 extends Applet

{


private static Random randy;


private int SIZE;



private Image offScreenImage;


private Graphics offScreenGraphics;




private int randomInRange(int low, int high) {…}


private double distance(int x1, int y1, int x2, int y2) {…}





public void init()


{



randy = new Random();



Dimension dim = getSize();



SIZE = dim.width;




drawCircle();


}




public void drawCircle() {



// DRAWS CIRCLE ON BOTH getGraphics() AND



// offScreenGraphics



}



public void drawDots(int numPoints)


{


// DRAWS numPoints RANDOM DOTS ON BOTH getGraphics()



// AND offScreenGraphics


}




public void paint(Graphics g)


{



g.drawImage(offScreenImage, 0, 0, null);


}

}

init

creates the
random number
generator & gets
applet size


drawDots

draws
the dots on the
screen and to the
off
-
screen buffer


paint

redraws the
screen using the
buffer

MontePI example (cont.)

<html>

<!
--

Monte7.html
--
>


<head>


<title>Monte Carlo Darts Page</title>

</head>


<body bgcolor="gray">


<div style="text
-
align:center">


<applet code="Monte7.class" name="MonteApplet"


height=300 width=300>


You must use a Java
-
enabled browser to view this applet.


</applet>



<br /><br />



<form name="MonteForm">


<input type="button" value="Generate points"


onClick="document.MonteApplet.drawDots(1000);">


</form>


</div>

</body>

</html>

here, HTML button
controls the applet
(via JavaScript)

Example (cont.)

<html>

<!
--

Monte7a.html
--
>


<head>


<title>Monte Carlo Darts Page</title>

</head>


<body bgcolor="gray">


<div style="text
-
align:center">


<applet code="Monte7.class" name="MonteApplet"


height=300 width=300>


You must use a Java
-
enabled browser to view this applet.


</applet>



<br /><br />



<form name="MonteForm">


<input type="button" value="Generate"


onClick="numDots = parseFloat(document.MonteForm.numPoints.value);


document.MonteApplet.drawDots(numDots);">


<input type="text" name="numPoints" size=6 value=100> points



<br /><br />


<input type="button" value="Clear the screen"


onClick="document.MonteApplet.drawCircle();">


</form>


</div>

</body>

</html>

better interface:


allow user to specify
number of dots in text
box


each click adds new
dots, have separate
button to clear

Dividing control

where the control lies affects the efficiency/usability of an applet


want the applet to be as self
-
contained as possible,

take advantage of speed advantage, more advanced features


but if GUI controls are in HTML, then JavaScript needs overall control

consider adding counters for number of dots inside & outside circle


have the applet keep track of the dots in instance variables


1.
after drawing all dots, JavaScript could access counts & display


can’t see counts in progress (in Netscape)


2.
could have applet update the HTML text boxes itself


tricky (example later)


3.
could return more control to the page, applet draws one dot at a time

repetition is handled by JavaScript, can update boxes after each dot



slower, but more flexible

JavaScript in control

import java.awt.*;

import java.applet.*;

import java.util.Random;


public class Monte8 extends Applet

{


. . .


public int numInside, numOutside;





. . .




public void clear()


{



numInside = 0; numOutside = 0;


. . .


}




public void drawDot()


{


. . .


if (distance(x, y, SIZE/2, SIZE/2) < SIZE/2) {


offScreenGraphics.setColor(Color.white);


g.setColor(Color.white);



numInside++;


}


else {


offScreenGraphics.setColor(Color.black);


g.setColor(Color.black);


numOutside++;


}


. . .


}


. . .

}

change applet so that
method only draws a
single dot
(repetition to be
controlled by JavaScript)



have applet keep track of
number inside & out

(can access & display with
JavaScript)

Example (cont.)

<html>

<!
--

Monte8.html
--
>


<head>


<title>Monte Carlo Darts Page</title>


<script type="text/javascript">


function doAll()


{


var numDots = parseFloat(document.MonteForm.numPoints.value);


for (var i = 0; i < numDots; i++) {


document.MonteApplet.drawDot();



}



document.MonteForm.numIn.value =
document.MonteApplet.numInside
;


document.MonteForm.numOut.value =
document.MonteApplet.numOutside
;


}



function clearAll()


{


document.MonteApplet.drawCircle();


document.MonteForm.numIn.value = 0;


document.MonteForm.numOut.value = 0;


}


</script>

</head>


<body bgcolor="gray">


<form name="MonteForm">


<table align="center">


<tr><td><applet code="Monte8.class" name="MonteApplet" height=300 width=300>


You must use a Java
-
enabled browser to view this applet.


</applet>


<td><input type="button" value="Generate" onClick="doAll();">


<input type="text" name="numPoints" size=6 value=100> points


<p><hr>


<p><input type="text" name="numIn" size=6 value=0> points inside


<p><INPUT TYPE="text" name="numOut" size=6 value=0> points outside


<p><hr>


<p><input type="button" value="Clear the screen" onClick="clearAll()">


</table>


</form>

</body>

</html>

Note: can utilize
HTML table to
achieve desired
layout of elements

Accessing HTML/JavaScript from the applet

it is possible for the applet to access elements in the page


requires the
JSObject

class from the
netscape.javascript

package


import netscape.javascript.JSObject;




use

getWindow

and

getMember

methods to access components


JSObject jsWin = JSObject.getWindow(this); // GETS WINDOW

JSObject jsDoc = (JSObject) jsWin.getMember("document"); // GETS DOCUMENT


JSObject MonteForm = (JSObject) jsDoc.getMember("MonteForm"); // GETS FORM





numInside = (JSObject) MonteForm.getMember("numIn"); // GETS TEXT BOX


use

getMember

and

setMember

methods to access component attributes


int num = Integer.parseInt( (String)numInside.getMember("value") );


numInside.setMember("value", ""+(num+1));

Related topics

JavaBeans


reusable components (e.g., buttons, menus) that can be packaged and reused


requires special tools for compiling and packaging (e.g., BDK)


downloaded with an applet using the
ARCHIVES

attribute


<applet code="javaApp.class" archives="jarfile.jar">

JAR files


for applets that are comprised of multiple classes, can bundle all necessary files into
a Java Archive (JAR) file


uses the popular ZIP file format


download using ARCHIVES attribute, automatically unzipped by browser

End of Java Applets