In "The Java Handbook" by Patrick Naughton (Osborne McGraw-Hill), there 
is in chapter 8 on pages 140-1 a program "PointPack" (the main class), 
which illustrates use of the interface concept.

Particularly intriguing is the author's concept of packing and unpacking 
a value or values for future use via persistence.

However, the last statement in the example does not produce the expected 
output, i.e., packed values on the left and original values on the 
right. The actual output of the statement:

	System.out.println("p = " + thawed);

is only the original (unpacked) values on the right ("thawed" is an 
object of class NewPoint, which has a toString() method for use by the 
'+' operator).

File "PointPackX.java" offers a solution.

The goal was to replace the final statement with something like:

	System.out.println(packed_array + " = " + thawed);

such that the String " = " appears as before and provides the 
"motivation" for the Java system to apply the toString() method in the 
classes of both objects.

Therefore, "packed_array" must be an object of a class (PackedArray), 
which prepares the packed values in readable dump format and has a 
suitable toString() method.

This version of PointPackX greatly simplifies encapsulating and retrieving
decimal to hexadecimal values. (An earlier version implemented a
Hashtable for this purpose, which, even though it worked, was overwrought
for what is needed.)

Class "DecToHex" is now about as short and simple as it gets. A StringBuffer
object contains hex digits 0 .. f, and the StringBuffer method CharAt()
providesfor retrieving a decimal value's corresponding hexadecimal value.

Class "PackedArray" encapsulates the data objects and methods for 
"dumping" (not unpacking) and returning the packed values in printable 
format. Note that the constructor invokes a method (AssignedPacked())to 
copy the packed array. This is a courtesy to the user (as you likely 
know, there is no counterpart in Java to the C++ "const" facility for 
guaranteeing non-destructive treatment of an argument). Method
System.arraycopy() replaces the earlier for(...) loop. This has two benefits:
1) The arraycopy() method is fast; 2) There is no pre-set limit on the size
of the array to be copied.

The constructor then invokes method ConvertPacked(), which masks out
the high- and low-order (left and right) parts ("nybbles") of each byte of the
packed array and uses the resulting values as arguments to the toHex() method
of class DecToHex. Finally, the desired toString() method will be
applied in the println() method.

The Java file was compiled and tested with the JDK 1.0.1 under Win95.

Jack Guyant
70372.3176