Java Newsletter by Glen McCluskey - Issue 11
Issue #011
November, 1996
Contents
- Newsletter Index
- Java Language Specification
- Comparing C/C++ and Java Part 11 - Preprocessing
- Introduction to Applet Programming Part 7 - Animation
- Performance - Binary Search Class
NEWSLETTER INDEX
An index to all the Java and C++ newsletters can be found on the Web at:
The index will be updated as new issues come out.
JAVA LANGUAGE SPECIFICATION
This is the name of a recently-published book by Gosling, Joy, and Steele, published by Addison-Wesley. It's about 800 pages and costs around $35. There are about 450 pages on the language proper, and 300 on the core packages like java.lang, java.util, and java.io. Included is a LALR(1) grammar for the language.
This is a good book if you're interested in the exact details of how the language and associated packages work. It's not a tutorial, and does go into a lot of depth about particular language features.
COMPARING C/C++ AND JAVA PART 11 - PREPROCESSING
C and C++ have a preprocessor that is run over source files before other processing. Java does not have a preprocessor.
One use of the preprocessor is to define constants:
#define N 79
In Java this can be accomplished by saying:
public static final int N = 79;
where "public" means that the constant is available to all, "static" means that it's shared by all object instances of a given class, and "final" means it cannot be changed after initialization.
Another use of the preprocessor is to define macros:
#define max(x, y) ((x) > (y) ? (x) : (y))
This is typically done for speed or readability. A good compiler reduces the need for this facility, by inline expanding short methods. This is an area of Java still in a state of flux, however.
The preprocessor can be used to #include other files into a source file. Java packages and naming conventions and import directives (see newsletters #003, #004, and #005) mostly eliminate the need for #include.
Finally, the preprocessor has directives like:
#ifdef XXX
stuff ...
#endif
to perform conditional compilation, typically on a per-platform basis. Java is a platform-independent language, and in theory such a directive is not needed. In practice, however, it would be useful to be able to do conditional compilation. For example, the AWT (Abstract Windowing Toolkit), may perform differently across platforms, due to the vagaries of the underlying window systems.
There's nothing to stop you from using your own preprocessor or macro processor, but such an approach is not part of the official Java language.
INTRODUCTION TO APPLET PROGRAMMING PART 7 - ANIMATION
In previous issues we've talked about the use of basic graphics in a Java applet, and considered some techniques for the input of text. In this issue we'll talk about something quite different, namely animation. This is a technique that can be used to make applets do "neat" things.
First of all, let's look at the source for an animation applet:
import java.applet.*;
import java.awt.*;
public class Animate extends Applet implements Runnable {
// thread identifier
private Thread an_thread = null;
// Start and Stop buttons
private Button start_button = null;
private Button stop_button = null;
// current state of animation
private int st = 0;
// initialize the applet
public void init()
{
start_button = new Button("Start");
stop_button = new Button("Stop");
add(start_button);
add(stop_button);
}
// handle mouse actions
public boolean action(Event e, Object arg)
{
if (e.target == start_button) {
start();
return true;
}
else if (e.target == stop_button) {
stop();
return true;
}
else {
return super.action(e, arg);
}
}
// start the applet
public void start()
{
if (an_thread == null) {
an_thread = new Thread(this);
an_thread.start();
}
}
// stop the applet
public void stop()
{
if (an_thread != null && an_thread.isAlive())
an_thread.stop();
an_thread = null;
st = 3;
}
// run a thread
public void run()
{
for (;;) {
// get graphics for the applet window
Graphics g = this.getGraphics();
try {
switch (st++) {
case 0:
g.setColor(Color.red);
g.fillOval(25, 35, 250, 250);
break;
case 1:
g.setColor(Color.yellow);
g.fillOval(125, 135, 150, 150);
break;
case 2:
g.setColor(Color.blue);
g.fillOval(225, 235, 50, 50);
break;
case 3:
g.clearRect(0, 0, 300, 300);
st = 0;
break;
}
// sleep for a second
Thread.sleep(1000);
}
catch (InterruptedException e) {
}
}
}
}
along with the HTML code that drives the applet:
<html>
<head>
<title>Interface to Animation Applet</title>
</head>
<body>
<applet code="Animate.class" width=300 height=300></applet>
</body>
</html>
We've seen parts of the applet code before, for example the graphics that draws ovals (actually circles in this example), the init() method, the setting up of buttons, and so on. This particular animation draws three circles of different sizes and colors, and then repeats itself.
What's different in this example is the use of threads. A thread, which also is called names like "lightweight process" and "task", is a distinct execution of Java code that is taking place at a given time. A program or applet may use threads to allow multiple streams of code to execute simultaneously.
Normally a Java applet responds to events such as mouse clicks or keyboard input. But we'd like this animation applet to do something continuously without waiting for events, so we create a thread and start it running. The lines:
an_thread = new Thread(this);
an_thread.start();
create a thread, specifying a reference for a class object that implements the Runnable interface (that is, defines a method run()). This method is executed as the "body" of the thread. In the case at hand, the method simply checks the current state and draws the appropriate circle or else clears the window in preparation for starting another cycle.
We've set up a couple of Start and Stop buttons, tied to start() and stop() methods in the applet. If Stop is selected, the thread execution stops, and Start will restart the animation by reestablishing the thread.
Threads are an important part of Java about which we will say more in future issues.
PERFORMANCE - BINARY SEARCH CLASS
As we've discussed previously, there are still some issues around the performance of Java, and thus there is a premium on the use of efficient algorithms.
One such algorithm is the familiar one of binary search, where a sorted list is searched by continually halving the search area until the desired element is found or it is determined that the element is not in the list.
In Java this might look like:
import java.util.Vector;
public class Search {
// no one should instantiate this class
// since it exists only as a packaging vehicle
// for the static method search()
private Search() {}
public synchronized static int search(Vector v, Object objp,
Orderable op)
{
if (v == null || objp == null || op == null)
throw new IllegalArgumentException("null arg");
int low = 0;
int high = v.size() - 1;
while (low <= high) {
int mid = (low + high) / 2;
int c = op.compareTo(objp, v.elementAt(mid));
if (c < 0)
high = mid - 1;
else if (c > 0)
low = mid + 1;
else
return mid;
}
return -1;
}
}
where an index 0 <= index < N is returned, or -1 if the element is not found. The Vector class found in Java does not automatically maintain a sorted order for the items in the vector.
This algorithm is straightforward save for the notion of an Orderable. What is this? An Orderable is an interface:
public interface Orderable {
public int compareTo(Object p1, Object p2);
}
If a given class implements an interface, that means that it defines the methods of the interface. This is the method of choice at the moment for passing a method reference as an argument, or in C/C++ terms, passing a pointer to a function. In other words, we create an instance of a class that implements the Orderable interface, which means that the instance will have a compareTo() method that we can call out to.
To see how this works, consider this example that uses the search class:
import java.util.*;
class Ord implements Orderable {
public int compareTo(Object p1, Object p2)
{
int n1 = ((Integer)p1).intValue();
int n2 = ((Integer)p2).intValue();
if (n1 > n2)
return 1;
else if (n1 < n2)
return -1;
else
return 0;
}
}
public class test {
public static void main(String args[])
{
Vector v = new Vector();
int N = 10000;
int i = 0;
for (i = 0; i < N; i++)
v.addElement(new Integer(i));
for (i = 0; i < N; i++)
Search.search(v, new Integer(i), new Ord());
}
}
We create a Vector of 10000 integers, each wrapped in an Integer wrapper. We then search for each in turn, passing to Search.search() an object instance of Ord, a class that implements the Orderable interface and thus is guaranteed to contain a compareTo() method for comparing two Object references that refer to Integer wrappers.
This approach is somewhat like the bsearch() library function in ANSI C. A similar technique can be used for sorting. The above search class is part of a Java class library described on the Web page:
http://rainbow.rmi.net/~glenm/javalib/index.html
ACKNOWLEDGEMENTS
Thanks to Jay Burgess, Thierry Ciot, Irv Kanode, Mike McCann, Mike Paluka, Srihari Sampathkumar, and Bob Shore for help with proofreading.
SUBSCRIPTION INFORMATION / BACK ISSUES
To subscribe to the newsletter, send mail to majordomo@world.std.com with this line as its message body:
subscribe java_letter
Back issues are available via FTP from:
rmi.net /pub2/glenm/javalett
or on the Web at:
There is also a C++ newsletter. To subscribe to it, say:
subscribe c_plus_plus
using the same majordomo@world.std.com address.
-------------------------
Copyright (c) 1996 Glen McCluskey. All Rights Reserved.
This newsletter may be further distributed provided that it is copied in its entirety, including the newsletter number at the top and the copyright and contact information at the bottom.
Glen McCluskey & Associates
Professional Computer Consulting
Internet: glenm@glenmccl.com
Phone: (800) 722-1613 or (970) 490-2462
Fax: (970) 490-2463
FTP: rmi.net /pub2/glenm/javalett (for back issues)
Web: http://rainbow.rmi.net/~glenm
