Java%20Applets - PowerPoint PPT Presentation

About This Presentation
Title:

Java%20Applets

Description:

originally designed for small, embedded systems in electronic appliances ... Hello1.html -- head title Hello World Page /title /head body p ... – PowerPoint PPT presentation

Number of Views:51
Avg rating:3.0/5.0
Slides: 50
Provided by: barbara132
Category:
Tags: 20applets | hello1 | java

less

Transcript and Presenter's Notes

Title: Java%20Applets


1
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

2
Java
  • 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

desired features (from the Java white
paper) simple object-oriented robust platform
independent architecture neutral portable dynamic
interpreted high-performance distributed multi-th
readed 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
3
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

4
Language features (cont.)
  • platform independence
  • want to be able to run Java code on multiple
    platforms
  • neutrality is achieved by mixing compilation
    interpretation
  • Java programs are translated into byte code by a
    Java compiler
  • byte code is a generic machine code
  • 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
  • architecture-neutral
  • no implementation dependent features
  • e.g., sizes of primitive types is set (unlike C)
  • portable
  • byte code will run on any version of the Java
    Virtual Machine (JVM)

5
Language features (cont.)
  • dynamic
  • JVM links classes at run-time as they are needed
  • if supporting class is recompiled, dont have to
    recompile entire project
  • interpreted
  • needed for platform independence
  • interpreted ? faster code-test-debug cycle,
    better run-time error checking
  • high-performance
  • faster than traditional interpretation since byte
    code is "close" to native code
  • still somewhat slower than a compiled language
    (e.g., C)

6
Language features (cont.)
  • 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
  • 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

7
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

8
Java applets
  • 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
  • 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

9
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

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

11
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

12
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

13
Embedding an applet in 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
  • lthtmlgt
  • lt!-- Hello1.html --gt
  • ltheadgt
  • lttitlegtHello World Pagelt/titlegt
  • lt/headgt
  • ltbodygt
  • ltpgt
  • ltapplet code"HelloWorld.class" height100
    width100gt
  • You must use a Java-enabled browser to view
    this applet.
  • lt/appletgt
  • lt/pgt
  • lt/bodygt
  • lt/htmlgt

14
HTML applets
  • lthtmlgt
  • lt!-- Hello2.html --gt
  • ltheadgt
  • lttitlegtHello World Pagelt/titlegt
  • lt/headgt
  • ltbodygt
  • ltpgt
  • ltdiv align"center"gt
  • lttable border1gt
  • lttrgtlttdgt
  • ltapplet code"HelloWorld.class" height200
    width200gt
  • You must use a Java-enabled browser to view
    this applet.
  • lt/appletgt
  • lt/tdgtlt/trgt

an applet can be embedded within HTML elements
just like any other element useful for
formatting and layout
15
Parameters in HTML
  • lthtmlgt
  • lt!-- Hello3.html --gt
  • ltheadgt
  • lttitlegtHello World Pagelt/titlegt
  • lt/headgt
  • ltbodygt
  • ltpgt
  • ltdiv align"center"gt
  • lttable border1gt
  • lttrgtlttdgt
  • ltapplet code"HelloWorld1.class" height35
    width300gt
  • ltparam name"name" value"Chris"gt
  • ltparam name"age" value20gt
  • You must use a Java-enabled browser to view
    this applet.
  • lt/appletgt
  • 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

16
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(getParamete
    r("age"))
  • String message1 "Hello " userName
    "."
  • String message2 "On your next birthday,
    you will be "
  • (userAge1) " 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

17
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)
  • . . .

18
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 lt nums.length i)
  • numsi 0
  • _____________________________ _
  • int nums new int10
  • Init(nums)

19
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
int10
20
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

21
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_WORDS100
  • private static Random randy
  • private int randomInRange(int low, int high)
  • return (Math.abs(randy.nextInt())
    (high-low1)) low
  • public void init()

Random class provides methods for generating
random values
can override init method to allocate initialize
(similar to a constructor)
ltapplet code"HelloWorld1.class" height200
width200gt You must use a Java-enabled browser
to view this applet. lt/appletgt
22
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, . . .

23
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_WORDS100
  • private static final Color colors
  • Color.black,Color.red,Color.blue,Color.green,Co
    lor.yellow
  • private static Random randy
  • private int RandomInRange(int low, int high)
  • return (Math.abs(randy.nextInt())
    (high-low1)) low

can store possible colors in an array change
drawing color using the setColor method
ltapplet code"HelloWorld2.class" height200
width200gt You must use a Java-enabled browser to
view this applet. lt/appletgt
24
Parameters applet dimensions
  • recall
  • can specify parameters in the HTML document using
    ltPARAMgt 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

25
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,Co
    lor.yellow
  • private static Random randy
  • private Dimension dim
  • private int numReps
  • private int RandomInRange(int low, int high)
  • return (Math.abs(randy.nextInt())
    (high-low1)) low

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
ltapplet code"HelloWorld3.class" height300
width400gt ltparam name"reps" value200gt You
must use a Java-enabled browser to view this
applet. lt/appletgt
26
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)

27
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("p
    oints"))
  • Dimension dim getSize()
  • SIZE Math.min(dim.width, dim.height)
  • public void paint(Graphics g)

init method creates random number generator
gets parameters paint method draws a circle
and a bunch of random points
ltapplet code"Monte1.class" height300
width300gt ltparam name"points" value20000gt
You must use a Java-enabled browser... lt/appletgt
28
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

29
Buffered applet
  • public class Monte2 extends Applet
  • . . .
  • private Image offScreenImage
  • private Graphics offScreenGraphics
  • . . .
  • public void init()
  • randy new Random()
  • NUM_POINTS Integer.parseInt(getParameter("p
    oints"))
  • Dimension dim getSize()
  • SIZE Math.min(dim.width, dim.height)
  • offScreenImage createImage(SIZE, SIZE)
  • offScreenGraphics offScreenImage.getGraphic
    s()
  • offScreenGraphics.setColor(Color.red)
  • offScreenGraphics.fillOval(0, 0, SIZE,
    SIZE)
  • for (int i 0 i lt NUM_POINTS i)

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 dont see image in
progress
ltapplet code"Monte2.class" height300
width300gt ltparam name"points" value20000gt
You must use a Java-enabled browser... lt/appletgt
30
Better buffering
  • public class Monte3 extends Applet
  • . . .
  • public void init()
  • randy new Random()
  • NUM_POINTS Integer.parseInt(getParameter("point
    s"))
  • Dimension dim getSize()
  • SIZE Math.min(dim.width, dim.height)
  • public void paint(Graphics g)
  • if (offScreenImage null)
  • offScreenImage createImage(SIZE, SIZE)
  • offScreenGraphics offScreenImage.getGraphic
    s()
  • offScreenGraphics.setColor(Color.red)
  • g.setColor(Color.red)
  • offScreenGraphics.fillOval(0, 0, SIZE,
    SIZE)

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
ltapplet code"Monte3.class" height300
width300gt ltparam name"points"
value20000gt lt/appletgt
31
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

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

public void paint(Graphics g) . . .
insideField.setText("0") outsideField.setTex
t("0") . . . if (distance(x, y, SIZE/2,
SIZE/2) lt SIZE/2) g.setColor(Color.white)
int value Integer.parseInt(insideF
ield.getText())1 insideField.setText(""val
ue) else g.setColor(Color.black)
int value Integer.parseInt(outsid
eField.getText())1 outsideField.setText(""
value) . . .
ltapplet code"Monte4.class" height300
width300gt ltparam name"points"
value20000gt lt/appletgt
33
GUI layout
  • public class Monte5 extends Applet
  • . . .
  • public void init()
  • randy new Random()
  • NUM_POINTS Integer.parseInt(getParameter("p
    oints"))
  • 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")

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
ltapplet code"Monte5.class" height300
width300gt ltparam name"points"
value20000gt lt/appletgt
34
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()

35
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

public void drawCircle() CODE FOR DRAWING
CIRCLE public void drawDots()
drawCircle() Graphics g getGraphics()
for (int i 0 i lt NUM_POINTS i)
CODE FOR DRAWING DOTS public void
paint(Graphics g) g.drawImage(offScreenIma
ge, 0, 0, null) public void
actionPerformed(ActionEvent e) if
(e.getSource() dotButton) drawDots()

ltapplet code"Monte6.class" height300
width300gt ltparam name"points"
value20000gt lt/appletgt
36
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

37
  • 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)

38
JavaScript vs. Java
  • 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
  • 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

39
Calling Java routines from JavaScript
  • 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
  • lthtmlgt
  • lt!-- Note works in Netscape only. --gt
  • ltheadgt
  • lttitlegtJavaJavaScript Demolt/titlegt
  • lt/headgt
  • ltbodygt
  • ltscript language"JavaScript"gt
  • document.write(java.lang.Math.random())
  • lt/scriptgt
  • lt/bodygt
  • lt/htmlgt

40
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()
41
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

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
42
MontePI example (cont.)
  • lthtmlgt
  • lt!-- Monte7.html --gt
  • ltheadgt
  • lttitlegtMonte Carlo Darts Pagelt/titlegt
  • lt/headgt
  • ltbody bgcolor"gray"gt
  • ltdiv style"text-aligncenter"gt
  • ltapplet code"Monte7.class"
    name"MonteApplet"
  • height300 width300gt
  • You must use a Java-enabled browser to view
    this applet.
  • lt/appletgt
  • ltbr /gtltbr /gt
  • ltform name"MonteForm"gt
  • ltinput type"button" value"Generate
    points"
  • onClick"document.MonteApplet.drawDots(10
    00)"gt

here, HTML button controls the applet (via
JavaScript)
43
Example (cont.)
better interface allow user to specify number
of dots in text box each click adds new dots,
have separate button to clear
  • lthtmlgt
  • lt!-- Monte7a.html --gt
  • ltheadgt
  • lttitlegtMonte Carlo Darts Pagelt/titlegt
  • lt/headgt
  • ltbody bgcolor"gray"gt
  • ltdiv style"text-aligncenter"gt
  • ltapplet code"Monte7.class"
    name"MonteApplet"
  • height300 width300gt
  • You must use a Java-enabled browser to view
    this applet.
  • lt/appletgt
  • ltbr /gtltbr /gt
  • ltform name"MonteForm"gt ltinput
    type"button" value"Generate"
    onClick"numDots parseFloat(document.MonteForm.n
    umPoints.value)
    document.MonteApplet.drawDots(numDots)"gt
    ltinput type"text" name"numPoints" size6
    value100gt points ltbr /gtltbr /gt
    ltinput type"button" value"Clear the screen"
    onClick"document.MonteApplet.drawCircle(
    )"gt lt/formgt
  • lt/divgt
  • lt/bodygt

44
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
  • after drawing all dots, JavaScript could access
    counts display
  • cant see counts in progress (in Netscape)
  • could have applet update the HTML text boxes
    itself
  • tricky (example later)
  • 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

45
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()

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)
46
Example (cont.)
  • lthtmlgt
  • lt!-- Monte8.html --gt
  • ltheadgt
  • lttitlegtMonte Carlo Darts Pagelt/titlegt
  • ltscript type"text/javascript"gt
  • function doAll()
  • var numDots parseFloat(document.MonteFor
    m.numPoints.value)
  • for (var i 0 i lt numDots i)
  • document.MonteApplet.drawDot()
  • document.MonteForm.numIn.value
    document.MonteApplet.numInside
  • document.MonteForm.numOut.value
    document.MonteApplet.numOutside
  • function clearAll()
  • document.MonteApplet.drawCircle()

Note can utilize HTML table to achieve desired
layout of elements
47
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("docum
    ent") // 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.getM
    ember("value") )
  • numInside.setMember("value", ""(num1))

48
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
  • ltapplet code"javaApp.class" archives"jarfile.jar
    "gt
  • 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

49
End of Java Applets
Write a Comment
User Comments (0)
About PowerShow.com