Javascript [Electronic resources] : The Definitive Guide (4th Edition) نسخه متنی

22.1 Scripting Java Applets

As
discussed in Chapter 14, all Java applets embedded
in a web page become part of the
Document.applets[] array. Also, if given a
name or id, an applet can be
accessed directly as a property of the Document object. For example,
the applet created by an <applet> tag with a
name attribute of "chart" can be
referred to as document.chart.

The public fields and

methods of every applet are
accessible to JavaScript as if they were the properties and methods
of a JavaScript object. For example, if an applet named
"chart" defines a field named
lineColor whose type is String,
a JavaScript program can query and set this field with code like
this:

var chartcolor = document.chart.lineColor;  // Read an applet field
document.chart.lineColor = "#ff00ff";// Set an applet field 

JavaScript can even query and set the values of fields that are
arrays. Suppose that the chart applet defines two fields declared as
follows ( Java code):

public int numPoints;
public double[] points; 

A JavaScript program might use these fields with code like this:

for(var i = 0; i < document.chart.numPoints; i++)
document.chart.points[i] = i*i; 

This example illustrates the tricky
thing about connecting JavaScript and Java: type conversion. Java is
a strongly typed language with a fair number of distinct primitive
types. JavaScript is loosely typed and has only a single numeric
type. In the previous example, a Java integer is converted to a
JavaScript number and various JavaScript numbers are converted to
Java double values. There is a lot of work going
on behind the scenes to ensure that these values are properly
converted as needed. Later in this chapter, we'll consider the
topic of data type conversion in detail.

In addition to querying and setting the fields of a Java applet,
JavaScript can also invoke the methods of an applet. Suppose, for
example, that the chart applet defines a method named
redraw( ). This method takes no arguments and
simply serves to notify the applet that its
points[] array has been modified and it should
redraw itself. JavaScript can invoke this method just as if it was a
JavaScript method:

document.chart.redraw(  ); 

JavaScript can also call methods that take arguments and return
values. The underlying LiveConnect or ActiveX scripting technology
does the work of converting JavaScript argument values into legal
Java values and converting Java return values into legal JavaScript
values. Suppose the chart applet defines Java methods like these:

public void setDomain(double xmin, double xmax);
public void setChartTitle(String title);
public String getXAxisLabel(  ); 

JavaScript can call these methods with code like this:

document.chart.setDomain(0, 20);
document.chart.setChartTitle("y = x*x");
var label = document.chart.getXAxisLabel(  ); 

Finally, note that Java methods can return Java objects as their
return values, and JavaScript can read and write the public fields
and invoke the public methods of these objects as well. JavaScript
can also use Java objects as arguments to Java methods. Suppose the
Java applet defines a method named getXAxis( )
that returns a Java object that is an instance of a class named Axis
and a method named setYAxis( ) that takes an
argument of the same type. Now, suppose further that Axis has a
method named setTitle( ). We might use these
methods with JavaScript code like this:

var xaxis = document.chart.getXAxis(  ); 
 // Get an Axis object
var newyaxis = xaxis.clone(  );// Make a copy of it
newyaxis.setTitle("Y"); // Call a method of it...
document.chart.setYAxis(newyaxis); // and pass it to another method

There is one complication when we use JavaScript to invoke the
methods of a Java object. Java allows two or more methods to have the
same name, as long as they have different argument types. For
example, a Java object could declare these two methods:

public String convert(int i);     // Convert an integer to a string
public String convert(double d);  // Convert a floating-point number 

JavaScript has only one numeric type and doesn't distinguish
between integers and floating-point values, so
when you use JavaScript to pass a number to the method named
"convert", it cannot tell which one you intended to call.
In practice, this problem doesn't arise often, and it is
usually possible to work around it by simply renaming the methods as
needed. The latest versions of LiveConnect (in Netscape 6.1 and
later) also allow you to disambiguate cases like this by including
the argument types in the method name. For example, if the two
methods above were defined by document.applets[0],
you could disambiguate them like this:

var iconvert = document.applets[0]
["convert(int)"];  // Get int method
iconvert(3);  // Invoke the method like this