java overview

Java Overview

Java Overview Design goals & features

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

Programming modelsapplications 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 featuresthe desire for backward compatibility led to the retention of many bad features

Java

desired features (from the Java white paper):simple object-oriented robustplatform independent architecture neutral portabledynamic interpreted high-performancedistributed multi-threaded secure

note: these are desirable features for any modern languagethus, Java has become very popular, especially when Internet relatedalso, 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 compatibilityApplications 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 appletimport 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




comments in Java

// and /* . . . */ work the same as in C++

/** . . . */ designate documentation comments can be used to automatically generate HTML documentation (javadoc)




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




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>

<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 sizetext between the APPLET tags is displayed if unable to execute (e.g., Java not enabled)

OBJECT tagpreferred for HTML 4, but not universally supported

HTML & applets<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>

<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 parametersimport 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 documentgetParameter 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 objectsJVM 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 variableType [](index) operatorString toString()...

Java provides extensive libraries of data structures & algorithmsjava.util Vector Stack LinkedList

Dictionary HashTable RandomCalendar

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 Objects, 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 & coercesString value2 = (String)things.pop(); // pops & coerces

Hello againimport 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 helloimport java.awt.*;import java.applet.*;import java.util.Random;


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();}


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 helloimport java.awt.*;import java.applet.*;import java.util.Random;


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"));}


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

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

Graphical appletpublic 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);}


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 appletpublic 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); }}


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 bufferingpublic 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 boxespublic 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 layoutpublic 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


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(); }}

ActionListenerimport 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 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

http://javaboutique.internet.com/GraphApplet/

http://javaboutique.internet.com/Mandelbrot/

http://javaboutique.internet.com/Mandelbrot/

http://javaboutique.internet.com/gb2/

http://javaboutique.internet.com/DJSearch/

http://javaboutique.internet.com/Jatris/

Combining Java & JavaScript

integrating Java with JavaScriptcalling Java routines from JavaScriptcontrolling an applet from JavaScriptaccessing JavaScript & HTML elements from an applet

related topicsJavaBeans, 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>

<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 revisitedimport 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>

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

<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 timerepetition is handled by JavaScript, can update boxes after each dot slower, but more flexible

JavaScript in controlimport 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>

<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 WINDOWJSObject 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

java overview

Documents