Week 03

Variables: Named Compartments For Storing Values

In the last lecture we described a series of very simple programs to display text and the results of computations. For some uses these facilities may be adequate, but not for many. After all, you could get the results much more quickly on a calculator than by writing, compiling, and running a Java application.

The computer supplanted the calculator because it was better at very large calculations. Of course, large calculations are hard to write down as a single expression. For almost any application it is helpful to be able to store input values, intermediate results, and output values so that they may be referred to and updated in the course of a computation.

The computer, as we know, includes memory in which values can be stored. From the machine's point of view this memory is just a long list of storage positions which are accessed by specifying the number, or address of the desired cell. In higher-level languages, a variable is just a way to refer to a memory cell (or, often, a group of memory cells) by a meaningful name rather than by a numerical address.

Like a recipe, in most modern programming languages you begin a given block of a program with the variable declarations, a list of all the variables that will be used in that block. This serves two purposes, similar to those of an ingredients list. First, the reader can often get a rough sense of how a program works just by looking at the list of its variable declarations. Second, the compiler uses the declarations to determine how much storage it will need to ask the operating system for when it runs your program.

In order for the system to know how much space to set aside for a given variable, and how it should interpret the bit patterns in the space set aside, it needs to know what kind of value the variable is intended to refer to. Therefore, a variable declaration in Java specifies the type name and then the variable name, as in:

int foo; 

int foo, bar, baz; 

Should you declare your variables individually or in groups? It's mostly a matter of taste. The style we often use is to group variables into a single declaration if they are somehow logically connected by their meaning in the program, i.e.:

int height, width, depth;
int volume, area; 

The Type of a Variable

When you type an integer literal unadorned, it will be stored and treated as an int. If you would like to explicitly designate a literal as a long, you do it by appending the letter l to the number, as in the long literal 23456789876l.

It might seem best just to use the long type for all your integer variables. However, because most current processors work most quickly with 32-bit values, you should use int whenever its range is adequate. The shorter types should be used only when space considerations are paramount (since they may actually be slower than ints).

A double variable is (not suprisingly) double precision and uses eight bytes (64 bits) of storage. Values of type double are generally accurate to about fifteen digits. The smallest representable magnitude is approximately 4.94065645841246544e-324 and the largest is approximately 1.79769313486231570e+308.

While floats may be faster in some cases, doubles are probably the best choice for most applications. With only seven digits of accuracy, it is easy to get to the point of having significant round-off errors in calculations using float variables. For this reason, most of Java's buit-in math functions return double values. Java also assumes that floating point literals you write into a program are of type double. If you want to force a floating point literal to be of type float, add the letter f to the end of the literal.

In addition to the various numeric types, there are variable types for holding a variety of other kinds of data.

char foo = '!', bar = '\041', baz = '\u0021'; 

As with string literals, there is a problem writing quotes as character literals. The double quote is no problem. It is just '"'. But for the single quote we can't just write ''' since the middle single quote would appear to close the literal rather than being in the literal. This is why the escape code \' was introduced in the table of escape sequences last week.

So, for example, we might declare:

String name = "Josh Hodas",
       phone = "1 (909) 621-8650",
       dog = "Rufus"; 

boolean flag = true; 

Assigning A Value To A Variable

The Java assignment operator is the equals sign, =. An assignment statement consists of a variable name, followed by the assignment operator, followed by an expression. The effect of executing the statement is that the value of the expression on the right of the assignment operator is computed, and that value is stored in the variable named on the left.

For example, suppose we have the variable declaration:

int x, y, z; 

y = 2; 

x = y; 

z = 2 * x + 3; 

As a further example of using variables, the following program performs the same calculation of areas as the program in the last lecture, but using variables instead of literals:

// Program: VariableAreas
// Author:  Joshua S. Hodas
// Date:    July 26, 1996
// Purpose: To demonstrate the use of variables
 
class VariableAreas {
 
  public static void main(String args[]) {
 
    double squareSide, squareArea, circleRadius, circleArea;
	
    squareSide = 3;
    squareArea = squareSide * squareSide;
    
    circleRadius = squareSide / 2;
    circleArea = circleRadius * circleRadius * 3.141592653;
	
    System.out.println("Area of a " + squareSide + " by " +  
                     squareSide + "square: " + squareArea);
    System.out.println("Area of a circle of diameter " +  
                     2 * circleRadius + ": " + circleArea);
 
  }
 
}

The nice thing about this program is that now if we want to calculate the areas for a different size square and circle, all we need to change is the value assigned to the variable squareSide instead of looking for all the uses of the literals representing the side and radius.

x = x + 1; 

If you attempt to use the value of a variable before a value has been assigned, the compiler will generally raise an error. It will show the offending line and point at the unitialized variable. For example, if you had the following lines starting at line 10 of the file foo.java:

int x, y;
y = x + 1; 

foo.java:11 Variable may not have been initialized.
    y = x + 1;
        ^ 

In many circumstances you can combine the declaration of the variable and assigning its initial value into one step. This can save a bit of typing and make things clearer, as in:

int squareSide = 3; 

The expression used in the assignment is called the initializer, and can be any expression as long as it only uses literals and the variables already declared. Thus we could use the following declaration after, but not before, the last one:

int bigSquareSide = 2 * squareSide + 1; 

int y = 3, z = y + 1; 

Being Careful About Type Ranges

foo = 2147483648; 

On the other hand, if you use the statements:

foo = 2147483647;
foo = foo + 1; 

Note that some languages (notably, ML, which is studied in CS 131) are entirely type safe and will stop your program with a runtime error whenever you violate a type's range.

Type Casting

Of course this has absolutely nothing to do with Java! In Java, type casting refers to the act of replacing a value of one type in an expression with an equivalent value of another type.

• If a byte or short value is used with any of the Java operators, it is first promoted to an int. The exceptions to this rule are the increment and decrement operators, which are described below.

• If an int value is combined with a long value in an expression, it is first promoted to a long.

• If a value of any integer type is combined with a float value in an expression, it is first promoted to a float.

• If any numeric value is combined with a double value, it is first promoted to a double.

  Recall that floating point literals, unless explicitly marked as a float are of type double. So, combining any expression with an unadorned floating point literal will produce a double.

• If a value of one integer type is passed as an argument to a method (more on that in a couple of weeks) that is expecting a value of a "higher" integer type, the value is automatically promoted to that "higher" type.

• If a value of type float is passed as an argument to a method that is expecting a value of type double, the value is automatically cast to double.

• If a char value is combined with a numeric value in an expression, it is first converted to an int value holding the decimal Unicode code of the character.

  So, for example, since the exclamation point is ASCII and Unicode code decimal 33, the expression '!' + 2 evaluates to the int value 35.

• If a String and a char are added together, the result is a String consisting of the original string with the given character either prepended or appended, depending on whether the character was on the left or right of the addition operator.

• If a numeric value is added to a String, the result is a String consisting of the original String with the String representation of the numeric value either prepended or appended, depending on whether it was on the left or right of the addition operator.

System.out.println("This is the number thirty-three: " + 33); 

System.out.print("This is the number thirty-three: ");
System.out.println(33); 

"This is the number thirty-three: " + 33 

"This is the number thirty-three: 33" 

To signal an explicit cast request, you simply put the name of the type you wish to cast to in parentheses immediately before the expression whose value you want to cast. Here are a few typical examples:

• Suppose the char variable c holds a given character, and we wish to advance it to the next character. The expression c + 1 is an int, due to the automatic casting rules. To assign this back into c, it must first be cast back to a char. The desired statement is:

  c = (char) (c + 1); 
  

  Notice that the expression c + 1 has been put in parentheses. If this were not done, then the cast would only have applied to the value of the variable c, which is already a char, and thus the cast would have had no effect.

• When we first introduced automatic casting in last week's notes, we used the example of 4 / 3 which evaluated to 1. The solution was to type 4.0 / 3 instead. But suppose both these values were in int variables. You can't just add .0 after the variable name. The solution is to use an explicit cast, as in:

  int foo = 4, bar = 3;
  System.out.println((float) foo / bar); 
  

  Note that the explicit cast is being applied to one of the variables before the division is computed. If the expression were written (float) (foo / bar) the division would be done as integer division, and the result, 1, would then be cast to 1.0.

• Since almost all computations involving byte or short values will cause a cast upwards to int, if you want to assign the result back into a small type you will need to manually cast it downwards. Thus if b is a byte variable, the assignment

  b = b + 1; 
  

  will lead to the following compiler error:

  Incompatible type for =.
  Explicit cast needed to convert int to byte. 
  

  because the value of b was cast to an int in order for the additon with 1 to be performed and the result can't necessarily be safely stored into a byte.

  The solution is to use the following assignment:

  b = (byte) (b + 1); 
  

  You'll notice that this example is alot like the one with char above. In fact, because of its behavior, many C and C++ programmers tend to think of char as just another small integer type. We do not see any advantage in that point of view, however, and recommend against it.

A Word About Variable Names

x3 = x2 * x1; 

x3 = x2 * x1;     // Compute tax on annual income 

tax = taxRate * annualIncome; 

As with program and class names, a variable name is subject to the rules for Java identifiers, so it can be any string of alphabetic characters, digits (other than as the first character), or the characters $ and _, as long as it is not one of the Java reserved words.

More Arithmetic Operators

var += exp; 

var = var + exp; 

var++; 

var = var + 1; 

var--; 

var = var - 1; 

The increment and decrement operators can actually be put either before or after the variable name. If they come after, as above, they are called post-increment and post-decrement. If they come before, as in ++var or --var, they are called pre-increment and pre-decrement.

To make this more concrete, assume we have the declaration:

int foo, bar, baz; 

foo = 1;
bar = ++foo;
baz = foo++; 

foo = foo + 1; 

foo++; 

foo = foo++; 

foo = ++foo; 

a = a + 1; 

a++; 

The Math Package

• Math.sin -- Evaluates to the sine of the given angle.

• Math.cos -- Evaluates to the cosine of the given angle.

• Math.tan -- Evaluates to the tangent of the given angle.

These all behave just as you'd expect. So, for example,

double x = Math.cos(3.141592653); 

• Math.asin -- Evaluates to the angle whose sine is the given value.

• Math.acos -- Evaluates to the angle whose cosine is the given value

• Math.atan -- Evaluates to the angle whose tangent is the given value

• Math.atan2 -- This method takes two double arguments representing a cartesian coordinate pair. That pair of coordinates is equivalent to a polar coordinate pair consisting of a radius and angle. The angle (in radians) is the value returned (as a double).

  In general, Math.atan(y/x), where y and x are double values or variables, is equal to Math.atan2(y,x), even when x is zero. The presence of this method is largely a throwback to systems in which division by zero caused an overflow.

• Math.exp -- Takes a double as an argument and evaluates to a double containing the value of e (the base of the natural logarithms) raised to the given value.

• Math.pow -- Takes two double arguments and returns, as a double, the value of the first raised to the power given as the second argument. I.e., if x and y are variables of type double, the call Math.pow(x,y) exaluates to x raised to the y power.

• Math.log -- Takes a double as an argument and evaluates to a double containing its natural logarithm.

• Math.sqrt -- Takes a double as an argument and evaluates to a double containing its square root.

• Math.floor -- Takes a double as an argument and returns as double the largest integer value not greater than the argument.

  Note that while the return value is a whole number, it is returned as a double. That is, calling math.floor on 2.65 will return 2.0 rather than 2. This is because none of the integer types has great enough range to guarantee the ability to return the appropriate value.

  This method can also be used to truncate a floating point number to some set number of digits after the decimal point. For example, if you want to truncate the value in the double variable x to have at most two digits after the decimal, multiply it by 100, take the Math.floor of the result, and then divide by 100. That is:

  x = Math.floor(x * 100) / 100; 
  

• Math.ceil -- Takes a double as an argument and returns as double the smallest integer value not less than the argument.

• Math.rint -- Takes a double as an argument and returns as double the nearest integer value to the argument.

  If two double values that are mathematically integers are equally close, the method returns the one that is even. That is, Math.rint(3.5) returns the value 4.0, but Math.rint(2.5) returns 2.0.

• Math.round -- Like rint this method's purpose is to round to the nearest integer value. However, it returns that value in an integer variable rather than a floating point variable. The method has slightly different behavior, depending on the type of the argument passed to it. (Because it accepts more than one type for an argument, but varies its behavior based on the type, this is another example of an overloaded method like System.out.println.)

  If the argument is a float, then the rounded value is returned as an int. If the rounded value is outside the range of the int type then the largest or smallest int value is returned, whichever is appropriate.

  If the argument is a double, then the rounded value is returned as an long. If the rounded value is outside the range of the long type then the largest or smallest long value is returned, whichever is appropriate.

• Math.abs -- Takes a numeric argument and returns its absolute value. The type of the return value is the same as the argument type.

• Math.min -- Takes two numeric arguments and returns the smaller one. If both arguments are of type int the result is also an int. Similarly if both arguments are, long, float, or double, then that is the type returned. If the types are mismatched, the argument of "lower" type (not to be confused with the argument with the lesser value) is promoted to the "higher" type, and that is the return type of the result.

• Math.max -- Takes two numeric arguments and returns the larger one. The behavior is the same as min with respect to types.

• Math.random -- This is a method of no arguments (i.e. you call it by sending the message Math.random()). Each time it is called it returns a double containing a random value greater than or equal to 0.0 and less than 1.0.

  While this may seem of limited use, you can use it to generate floating point or integer random numbers in any range you want by a little manipulation. For example, if we want an integer choice between 1 and 10 inclusive, take the random double value returned, multiply it by 10 (yielding a floating point value greater than or equal to 0.0 and less than 10.0), add 1.0 (yielding a floating point value greater than or equal to 1.0 and less than 11.0), apply Math.floor to truncate the part after the decimal (yielding 1.0, or 2.0, or ... 10.0), and, finally, cast the result to an integer type.

  Note, the random numbers generated by Math.random are actually psuedo-random numbers, meaning that they are generated algorithmically and the value of the next one depends on the value of the one before it. They are, however, uniformly distributed over the range, and should be adequate for most purposes.

• Math.E -- An approximation of the base of the natural logarithms, this constant has the value 2.7182818284590452354.

• Math.PI -- An approximation of the ratio between the circumference of a circle and its diameter, this constant has the value 3.14159265358979323846.

  Using this, in the program given earlier, we could replace the line:

  circleArea = circleRadius * circleRadius * 3.141592653; 
  

  with the line:

  circleArea = circleRadius * circleRadius * Math.PI; 
  

Formatted Output Using HMCSupport.out

Because Java was designed mostly with applet construction in mind, Java's designers did not bother to make the System.out object very powerful, since they didn't think it would get used much. In this course, however, we will be working almost exclusively with applications, and will use character-based input and output a fair amount. Therefore, we have chosen to develop a replacement for System.out, which we call HMC.HMCSupport.out. We could have just replaced System.out with our output object and never told you about the change, but this way you will not be mislead into thinking that System.out has features it does not, which could cause problems if you began to program in Java in another environment.

import HMC.HMCSupport; 

You can add as many import statements to a program as you'd like. If a package has many sub-packages and you'd like to import them all, you put an asterisk in place of the sub-package name. For instance, the effect of having all the sub-packages of java.lang available automatically is due to an implicit statement of the form:

import java.lang.*; 

// Program: BadMultTable
// Author:  Joshua S. Hodas
// Date:    August 26, 1996
// Purpose: To demonstrate formatting problems
 
class BadMultTable {
  public static void main(String args[]) {
 
    System.out.print(1*1);
    System.out.print(" " + 1*2);
    System.out.print(" " + 1*4);
    System.out.println(" " + 1*6);
 
    System.out.print(2*1);
    System.out.print(" " + 2*2);
    System.out.print(" " + 2*4);
    System.out.println(" " + 2*6);
 
    System.out.print(4*1);
    System.out.print(" " + 4*2);
    System.out.print(" " + 4*4);
    System.out.println(" " + 4*6);
 
    System.out.print(6*1);
    System.out.print(" " + 6*2);
    System.out.print(" " + 6*4);
    System.out.println(" " + 6*6);
 
  }
}

The output from this program is:

1 2 4 6
2 4 8 12
4 8 16 24
6 12 24 36 

We can use this method to fix the multiplication table. We will just specify that all the values be printed in fields three characters wide. This will make the columns line up, and will also do away with the need to include spaces explicitely in the output messages.

// Program: GoodMultTable
// Author:  Joshua S. Hodas
// Date:    August 26, 1996
// Purpose: To demonstrate formatting with setWidth
 
import HMC.HMCSupport;
 
class GoodMultTable {
  public static void main(String args[]) {
 
    HMCSupport.out.setWidth(3);
    
    HMCSupport.out.print(1*1);
    HMCSupport.out.print(1*2);
    HMCSupport.out.print(1*4);
    HMCSupport.out.println(1*6);
 
    HMCSupport.out.print(2*1);
    HMCSupport.out.print(2*2);
    HMCSupport.out.print(2*4);
    HMCSupport.out.println(2*6);
 
    HMCSupport.out.print(4*1);
    HMCSupport.out.print(4*2);
    HMCSupport.out.print(4*4);
    HMCSupport.out.println(4*6);
 
    HMCSupport.out.print(6*1);
    HMCSupport.out.print(6*2);
    HMCSupport.out.print(6*4);
    HMCSupport.out.println(6*6);
 
  }
}

The output from the new program is:

  1  2  4  6
  2  4  8 12
  4  8 16 24
  6 12 24 36 

By default, when you specify a field width using setWidth, the output is padded on the left, so that the value is right-justified in the column. You may find yourself in a situation in which you would like the padding to go on the right, so that the value is left-justified. The current justification setting can be changed using the methods HMCSupport.out.setLeftJustify, HMCSupport.out.setRightJustify, and HMCSupport.out.setCenterJustify. All of these methods are called with no arguments. As with setWidth the effect of a call to one of these methods persists until it is replaced by a call to one of the other two.

// Program: TableOfContents
// Author:  Joshua S. Hodas
// Date:    August 26, 1996
// Purpose: To demonstrate justification and padding
 
import HMC.HMCSupport;
 
class TableOfContents {
  public static void main(String args[]) {
 
    HMCSupport.out.setPadChar('.');
 
    HMCSupport.out.setWidth(20);
    HMCSupport.out.setLeftJustify();
    HMCSupport.out.print("Chapter 1");
 
    HMCSupport.out.setWidth(5);
    HMCSupport.out.setRightJustify();
    HMCSupport.out.println(1);
 
    HMCSupport.out.setWidth(20);
    HMCSupport.out.setLeftJustify();
    HMCSupport.out.print("Chapter 12");
 
    HMCSupport.out.setWidth(5);
    HMCSupport.out.setRightJustify();
    HMCSupport.out.println(123);
 
  }
}

It's output is the two lines:

Chapter 1...............1
Chapter 12............123 

Make sure you read the program carefully to understand how each line effects the output generated.

When using HMCSupport.out, two methods can be used to control the presentation of floating point values. Calling HMCSupport.out.setPrecision with an integer argument sets the maximum number of digits to the right of the decimal point that should be shown when floating point values are displayed. If a displayed value has fewer fractional digits than the number specified with setPrecision then the output is unaffected; if it has more fractional digits, then the number is truncated (not rounded) as necessary. To disable truncation, returning the HMCSupport.out to its default behavior, call setPrecision with zero as its argument.

The last additional output control method provided by HMCSupport.out is HMCSupport.out.setFixed, which expects a boolean argument. When set to false, which is the default setting, there is no special behavior. When it is called with the argument true, then from that point on, floating point values with fewer fractional digits than specified by the last call to setPrecision are printed with zeroes added to the right to bring them up to the correct number of digits.

The following program demonstrates the behavior of these commands:

// Program: PrecisionControl
// Author:  Joshua S. Hodas
// Date:    August 27, 1996
// Purpose: To demonstrate control of floating point output
 
import HMC.HMCSupport;
 
class PrecisionControl {
  public static void main(String args[]) {
 
    HMCSupport.out.setWidth(10);
 
    HMCSupport.out.println(3.4);
    HMCSupport.out.println(3.456);
    HMCSupport.out.println(34.56);
    HMCSupport.out.println();
 
    HMCSupport.out.setPrecision(2);
 
    HMCSupport.out.println(3.4);
    HMCSupport.out.println(3.456);
    HMCSupport.out.println(34.56);
    HMCSupport.out.println();
 
    HMCSupport.out.setFixed(true);
 
    HMCSupport.out.println(3.4);
    HMCSupport.out.println(3.456);
    HMCSupport.out.println(34.56);
    HMCSupport.out.println();
 
  }
}

It's output is:

       3.4
     3.456
     34.56

       3.4
      3.45
     34.56

      3.40
      3.45
     34.56 

HMCSupport.out.println(x); 

HMCSupport.out.println("Some Label Text: " + x); 

Sometimes it is important to insure that the buffer has been flushed at a certain point. Suppose you are having trouble with a program that keeps crashing, and are trying to figure out at which point the failure is occuring. The quick-and-dirty solution is to add a few debugging output statements to the program that just display an indication that the program got that far. Well, if the program crashes but the buffer has not been flushed, you can't tell how far it got before crashing. Maybe it didn't get as far as a given debugging statement, or maybe it did but the output was still stuck in the buffer when the program crashed.

Most languages therefore provide a command that either forces the operating system to flush the output buffers immediately, or forces the program to wait until they have been flushed. In the core Java output routines the method is System.out.flush. In order to simplify things, HMCSupport.out has been designed to force the flushing of the output buffers every time it prints something. If, however, you are concerned about output execution speed, this can be disabled using the method HMCSupport.out.setAlwaysFlush which expects a boolean argument. If you have disabled automatic flushing and wish to force the buffers to flush, use HMCSupport.out.flush, which is a method of no arguments.

User Input Using HMCSupport.in

System.in is designed almost exclusively for string input. Getting numerical input requires reading a string and then using various conversion methods to get the desired type out of it. This can be cumbersome, and, in this course, is a low-level detail that distracts from the tasks at hand. Therefore, we have provided HMC.HMCSupport.in for use in this course. It provides a much broader and easier-to-use range of input routines.

While there are ways to establish a direct connection with the keyboard, the programming involved makes these techniques beyond the scope of this course..

• HMCSupport.in.nextWord -- Takes the token of input from the input stream and returns it as a String.

• HMCSupport.in.nextInt -- Takes the token of input from the input stream. If that string of characters can reasonably be interpreted as an int value, then that value is returned as an int.

  If the token cannot be interpreted as an int value, then the token is pushed back onto the front of the input stream (so that it will be read again the next time an input method is called) and the method returns the value 0.

• HMCSupport.in.nextLong -- Takes the token of input. If that string of characters can reasonably be interpreted as a long value, then that value is returned as an long.

  If the token cannot be interpreted as a long value, then the token is pushed back onto the front of the input stream and the method returns the value 0.

• HMCSupport.in.nextFloat -- Takes the token of input. If that string of characters can reasonably be interpreted as a float value, then that value is returned as an float.

  If the token cannot be interpreted as a float value, then the token is pushed back onto the front of the input stream and the method returns the value 0.0.

• HMCSupport.in.nextDouble -- Takes the token of input. If that string of characters can reasonably be interpreted as a double value, then that value is returned as an double.

  If the token cannot be interpreted as a double value, then the token is pushed back onto the front of the input stream and the method returns the value 0.0.

The following program once again computes the areas of a square and a circle. This time it uses HMCSupport.in to get the cross-section from the user. Notice that a bit of informative output has been added to the beginning of the program. If a program will interact with the user, you should always give them an overview up front as to what the program does. Also note that the prompt that is printed to elicit input is displayed with HMCSupport.out.print (rather than HMCSupport.out.println) so that the user's entry follows it on the same line.

// Program: InputAreas
// Author:  Joshua S. Hodas
// Date:    August 26, 1996
// Purpose: To demonstrate the use of user input
 
import HMC.HMCSupport;
 
class InputAreas {
 
  public static void main(String args[]) {
 
    double squareSide, squareArea, circleRadius, circleArea;
 
    HMCSupport.out.println("This program computes the areas"
                           + " of a square and circle of a"
                           + " given cross-section.");
    HMCSupport.out.println();
 
    HMCSupport.out.print("Enter the cross-section: ");
 
    squareSide = HMCSupport.in.nextDouble();
    squareArea = squareSide * squareSide;
 
    circleRadius = squareSide / 2;
    circleArea = circleRadius * circleRadius * Math.PI;
 
    HMCSupport.out.println();
    HMCSupport.out.print("Area of a " + squareSide + " by " +
                     squareSide + " square: ");
    HMCSupport.out.println(squareArea);
    HMCSupport.out.print("Area of a circle of diameter " +
                     2 * circleRadius + ": ");
    HMCSupport.out.println(circleArea);
 
  }
 
}

If you call the method HMCSupport.in.good (with no arguments) it will return true if the last input attempt was successful, and false if the token read was not of the appropriate type.

The CLASSPATH Environment Variable

When you first set up your account to use Java, the setup program should have configured your account so that your CLASSPATH variable has the value .:/home/cs/cs5/java. This tells the compiler to continue its search for classes first in the current directory, and then in the directory /home/cs/cs5/java. That is where we have stored any packages that we will Supply for use in the course.

You can confirm that your CLASSPATH variable is properly set by typing

printenv CLASSPATH 

setenv CLASSPATH  .:/home/osiris/cs/cs5/java