---

Note	Sun, which developed Java, has online documentation and tutorial at http://java.sun.com/doc.html

---

Two Kinds of Programs
Java is very similar to C++, particularly in the syntax of its statements. However, Java is a true object-oriented (OO) language, whereas C++ is a hybrid between an OO and a procedural language, such as C. For example, in Java, every function is a method in a class.
    

There are two forms of a Java program, an application, which is a stand-alone Java program, and an applet, which is a program that can run within a Java-compatible browser. A Java compiler translates source code into device-independent bytecode, or platform-independent code that a Java runtime system can interpret. We say that the program is compiled to a Java virtual machine. The bytecode is comparable to a machine language code for this imaginary machine. The Java runtime system on a real computer translates these bytecodes into the real machine code for that computer, which executes the program.

---

Basic Programs
The following is the Java application program HelloWorldAppl.java that displays "Hello World!":

//
// HelloWorldAppl.java
// Application to display "Hello World"
//
public class HelloWorldAppl 
{
   public static void main(String args[])  
   {
      System.out.println("Hello World!");
   }
}

public static void main(String args[]) 

javac HelloWorldAppl.java

java HelloWorldAppl

//
// echo.java
// Application to display its command-line arguments.
//
public class echo{
   public static void main(String[] args) 
   {
      for (int i = 0; i < args.length; i++)    
         System.out.println(args[i]);
   }
}

java echo Here we go!

Here
we
go!

final double AVOGADRO = 6.023e23;

Class Definition and Object Creation
Frequently, each class is in its own file, which has the name of the class and the extension .java. If several classes are in one file, only the class that shares the name of the file is publicly accessible. Below is a file point.java for a point class that encapsulates the data and methods for a point in two dimension. Unlike C++, we do not have a header file with the class prototype. The x and y coordinates, x and y, respectively, are private double variables, while the methods are public. Constructors initialize the point to the origin or with parameter arguments. A constructor has no return type, not even void; and the default constructor has no parameters. Methods return the distance of the point to the origin or to a parameter point. Recall that the distance of (x, y) to the origin is , while the distance between (x, y) and point (a, b) is . To compute the square root, we use the sqrt method in the Math class, such as Math.sqrt(x * x + y * y). (See the "Math Class" section below for other methods and constants.) To instantiate the origin, we have new point(0.0, 0.0). The method DistanceToOrigin calls method DistanceToPoint with the origin as the argument. The file point.java follows:

// point.java 
// Implementation of point class
class point 
{
   private double x;
   private double y;
   // Default constructor to create origin
   // Pre:  none
   // Post: This object represents origin (0.0, 0.0).
   public point() 
   {
      x = 0.0;
      y = 0.0;
   }
   // Constructor to create point from parameter coordinates
   // Pre:  xCoord and yCoord are double coordinates
   // Post: The object represents the point (xCoord, yCoord).
   public point(double xCoord, double yCoord) 
   {
      x = xCoord;
      y = yCoord;
   }
   // Method to return distance of this point to origin
   // Pre:  The point exists.
   // Post: The function returned the distance of the point to origin.
   public double DistanceToOrigin() 
   {
     return DistanceToPoint(new point(0.0, 0.0));
   }
   // Method to return distance of this point to a parameter point
   // Pre:  p is a point.
   // Post: The function returned the distance of the point to p.
   public double DistanceToPoint(point p) 
   {
     return Math.sqrt(((x - p.x) * (x - p.x)) + 
                      ((y - p.y) * (y - p.y)));
   }
}

point pt = new point(5.1, 2.73);

// 
// TestPoint.java - implementation of TestPoint class to
// test point class
//
class TestPoint {
   public static void main(String[] args) 
   {
      point pt = new point(5.1, 2.73);
      System.out.println("The distance to origin is " + 
            pt.DistanceToOrigin() + ".");
      point pt1 = new point(4.4, 8.4);
      System.out.println("The distance between the points is " + 
            pt.DistanceToPoint(pt1) + ".");
    }
  }

The distance to origin is 5.784712611703368.
The distance between the points is 5.713046472767397.

class chemistry extends science {...

public abstract class experiment {...

public abstract String ExperimentName();

public interface LifeStudy {
   public abstract boolean animal();
   ...
}

class biology extends science implements LifeStudy {
   public abstract boolean animal() {
     //definition of method goes here
     ...
   }
   ...
}  

public class addition extends Applet {...

public class clock extends Applet implements Runnable {...

import java.io.*;

import java.io.System;

package usr.username.sciences;
class physics extends science {
  ...
}

import usr.username.sciences.*;

import sciences.*;

set CLASSPATH = /usr/username;/usr/username/classes

Integer QuantityObj = new Integer(5);

int quantity = QuantityObj.intValue();

String  IntString  = "3572";
Integer IntWrapper = new Integer(IntString);
int     IntValue   = IntWrapper.intValue();

Integer QuantityObj    = new Integer(5);
String  StringQuantity = QuantityObj.toString();

double[] readings;

readings = new double[100];

double[] readings = new double[100];

int[] monthDays = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};

import java.util.Vector;

import java.util.*;

Vector readings = new Vector();

readings.setSize(100);

System.out.println("Number of elements = " + readings.size() );

readings.setElementAt(new Double(57.3), 3);

System.out.println("Element with index 3 = " + readings.elementAt(3) );
Double x = (Double)readings.elementAt(3);

readings.addElement(new Double(25.44));

String chemical = "sodium chloride";
String chemical = new String("sodium chloride");

char ch = chemical.charAt(2);

System.out.println(chemical.length());

System.out.println(chemical.indexOf('i'));

System.out.println(chemical.indexOf("ium"));

System.out.println(chemical.indexOf('i', 4));

String str = chemical.substring(7, 11);

String AnotherChemical = chemical.substring(7, chemical.length());

if (chemical.equals(chemical2))...

if (chemical.equals("sodium chloride"))...

String element1  = "copper";
String element2 = "zinc";

if (element1.compareTo(element2) < 0)
System.out.println(element1 + " occurs before " + element2);
else
System.out.println(element1 + " occurs after " + element2);

copper occurs before zinc

copper occurs after ZINC

System.out.println("solution of " + chemical);

String b = "barium";
String h = " hydroxide";
String c = b + h;
b += h;

StringBuffer t = s.append('G');

s.insert(2, "CC");

s.reverse();

As with Integer, Float, and Double, StringBuffer has a method toString to return the String object equivalent to the string buffer argument. Also, we can test if two StringBuffer objects are equal with equals. However, the StringBuffer class does not have methods compareTo, endsWith, startsWith, and substring. Table 4 lists some of the StringBuffer methods.

Table 4. Some methods in the StringBuffer class

Method	Meaning
append(obj)	Appends Object obj, converted to String, onto end of this string and returns result
charAt(index)	Returns character at position index
equals(obj)	Returns true if this string is not null and equals Object obj, converted to String
insert(index, obj)	Inserts Object obj, converted to String, at index index and returns result
length()	Returns length of string
reverse()	Reverses current string and returns result
setCharAt(index, ch)	Changes character at index index to ch
toString()	Returns String equivalent of this string buffer

Quick Review Question

Quick Review Question 8  Suppose m is a StringBuffer object. For each question, assume m has the value "mass". Do not use quotation marks in your answers. What is the value of m after execution of each of the following statements? a. m.append("es"); b. m.insert(3, '\''); c. m.reverse(); d. m.setCharAt(1, 'o');

---

Parameters
Java uses pass by value for its arguments, where the value of an argument is copied into the corresponding parameter. If the type of the argument is primitive, such as int or char, the method's actions on the parameter cannot change the value of the argument.

Example 1   Suppose main contains the declaration of an int variable quantity that has the value 100. In main, we instantiate an object t in the class change. Then, we call t's method inflation with the argument quantity. The following code segment from main displays the value of quantity before and after the call: public static void main(String[] args) {    int quantity = 100;     System.out.println("Before calling change50, quantity = "    + quantity);    change t = new change();    t.change50(quantity);    System.out.println("After calling change50, quantity = " +   quantity); } Suppose the method change50 in a class change has a parameter q that corresponds to quantity. The definition of change50 is as follows: class change { ...   public void change50(int q)   {      q = 50;      System.out.println("In change50, q = " + q);   } ... } The value of quantity (100) is passed by value and, thus, is copied into q. When q is assigned the value 50 inside the method, the value of quantity is not altered. As Figure 2 illustrates and the output verifies, the call to change50 does not change the value of quantity in the calling method: Before calling change50, quantity = 100 In change50, q = 50 After calling change50, quantity = 100

Figure 2. Action of the pass by value call to change50 of Example 1

Call change50					Assignment
quantity of main:		100			100
q of change50:		100			50

When we pass an object to a method, we are actually passing by value the reference to the object. In effect, Java uses a technique called pass by reference for object argument-parameter pairs. The reference is copied into the corresponding parameter. If the method changes a data value of the object, the method is altering the contents of the argument object. Although the argument still references the original object, the value that object stores is now different.

Example 2   Suppose the class obj has a private int data member x that a constructor initializes to 100. The method PutObj changes x to the value of a parameter, and another method GetObj returns x. The definition of obj follows: public class obj { private int x; // construct an object containing 100 public obj() { x = 100; } // change the stored data public void PutObj(int xint) { x = xint; } // return the stored data public int GetObj() { return x; } } Suppose in main we instantiate object QuantityObj in the class obj and an object t in the class change. We pass QuantityObj to the parameter qObj in the t method ChangeObj50. ChangeObj50 calls the qObj method PutObj to change the data member of qObj to 50. Code segments for main and ChangeObj50 follow: public static void main(String[] args) { obj QuantityObj = new obj(); System.out.println("Before calling ChangeObj50, QuantityObj: " + QuantityObj.GetObj()); change t = new change(); t.ChangeObj50(QuantityObj); System.out.println("After calling ChangeObj50, QuantityObj: " + QuantityObj.GetObj()); } class change { ... public void ChangeObj50(obj qObj) { qObj.PutObj(50); System.out.println("In ChangeObj50, qObj stores " + qObj.GetObj()); } ... } Because we are changing the data that qObj stores and not the object reference, Figure 3 and the following output illustrate that the assignment in ChangeObj50 alters the data that the argument object QuantityObj contains: Before calling ChangeObj50, QuantityObj: 100 In ChangeObj50, qObj: 50 After calling ChangeObj50, QuantityObj: 50

Figure 3. Action of the call to ChangeObj50 of Example 2

Call ChangeObj50			Assignment
QuantityObj of main:	100		50
qObj of ChangeObj50:

Java passes an object reference to a called method. Within the method, assignment of an object to the parameter changes that reference. Consequently, the object in the calling function does not change.

To summarize, if we change a data member of an object parameter, the value of the argument object changes. If we assign another object to an object parameter, the value of the argument object does not change.

Example 3    Suppose in main we instantiate an Integer object QuantityInteger to contain the value 100. After instantiating a change object t, main calls t's ChangeInteger50 method using the argument QuantityInteger, as follows: Integer QuantityInteger = new Integer(100); System.out.println("Before calling ChangeInteger50, QuantityInteger = " + QuantityInteger.intValue()); change t = new change(); t.ChangeInteger50(QuantityInteger); System.out.println("After calling ChangeInteger50, QuantityInteger = " + QuantityInteger.intValue()); Suppose that the parameter qInteger corresponds to QuantityInteger and that we assign a new Integer object to qInteger within ChangeInteger50, as follows: class change { ... public void ChangeInteger50(Integer qInteger) { qInteger = new Integer(50); System.out.println("In ChangeInteger50, qInteger = " + qInteger.intValue()); } ... } Because a change of a parameter's object reference inside ChangeInteger50 does not affect the argument's object, the following output shows that QuantityInteger continues to store 100 (see Figure 4): Before calling ChangeInteger50, QuantityInteger = 100 In ChangeInteger50, qInteger = 50 After calling ChangeInteger50, QuantityInteger = 100

Figure 4. Action of the call to ChangeInteger50 of Example 3

Call ChangeInteger50			Assignment
QuantityInteger of main:	100		100
qInteger of ChangeInteger50:			50

---

Standard StreamsThe three standard streams are as follows:

• System.in for reading from standard input, such as the keyboard
• System.out for writing to standard output, such as the screen
• System.err for writing to error messages

System.out and System.err each have a method println for displaying the output and then advancing to a new line. The method print displays the output but does not advance to a new line. Consider the following segment:

System.out.print("1");
System.out.println("2");
System.out.println("3");

The output displays 1 and 2 on the same line, as follows:

1 2
3

To read a string interactively, we instantiate a BufferedReader object and employ its readLine method, as follows:

BufferedReader stdin = new BufferedReader 
		(new InputStreamReader(System.in));
String str;
	
System.out.println("Type a string: ");
str = stdin.readLine();

---

Files
To read an input file, we must create an input stream associated with the file. An instance of the class FileInputStream is a file input stream. For example, if the file on disk is FileIn.dat, we can create an associated file input stream infile, as follows:

FileInputStream infile = new FileInputStream("FileIn.dat");

We read from such a stream one byte at a time. To read entire items, such as floating point numbers or strings, we form a StreamTokenizer instance from the infile, as follows:

StreamTokenizer InfileToken = new StreamTokenizer(infile);

Alternatively, we can form InfileToken in one statement, as follows:

StreamTokenizer InfileToken = new StreamTokenizer(									
				 new FileInputStream("FileIn.dat"));

To obtain the first or next item in the file, we call the InfileToken's nextToken method:

InfileToken.nextToken();

If the file item is a number, the method returns the value of its instance variable TT_NUMBER. (TT is an acronym for token type.) In this case, nextToken reads a double value into the object's nval instance variable. Thus, if the value nextToken returns is equal to the method's TT_NUMBER, then the instance variable nval contains the input. The following segment, reads and displays an item provided that item is a number:

int token = InfileToken.nextToken();

if (token == InfileToken.TT_NUMBER)
	System.out.println(InfileToken.nval);

To interpret the value as an integer, we cast it to int, as follows:

int IntegerValue  = (int)InfileToken.nval;

The input stream can contain a string, delimited by whitespace or by quotation marks. In this case, nextToken's sval instance variable stores the item from the input stream, and we can display the value as follows:

System.out.println(InfileToken.sval);

If the input string is inside quotation marks, such as

"This is a string in quotation marks."

nextToken reads the entire string and drops the quotation marks for the value in sval. If the string is delimited by whitespace, such as a word, nextToken returns the value of the instance variable TT_WORD. In the following statement, if the input is a "word," we display that string:

if (InfileToken.nextToken() == InfileToken.TT_WORD)
	System.out.println(InfileToken.sval);

If there is an attempt to read beyond the end of the file, the method nextToken returns a value equal to the instance variable TT_EOF. Thus, we can read and process all values in the file with the following loop:

while (InfileToken.nextToken() != InfileToken.TT_EOF)
{
	...
}

To produce an output file, we first instantiate a FileOutputStream object (such as outfile) and associate it with a disk file (such as, "FileOut.dat"), as follows:

FileOutputStream outfile = new FileOutputStream("FileOut.dat");

We can write to this stream one byte at a time. To write numbers or strings to the file, we instantiate a PrintStream object from outfile, as the following illustrates:

PrintStream OutputToken = new PrintStream(outfile);

As with input files, we can consolodate these two statements into one and omit the intermediate object outfile:

PrintStream OutputToken = new PrintStream(
			    new FileOutputStream("FileOut.dat"));

The PrintStream method println writes an output stream and advances to the next line, while print writes but does not advance to a new line.

After we have finished using a file, we should close the file stream variable, whether it is a FileOutputStream or a FileInputStream object. To close, we invoke the object's close method, such as follows:

outfile.close();
infile.close();

In the next section on "Exceptions," we see how to capture errors, such as not finding the file or not having proper data.

Quick Review Question

Quick Review Question 9  a. What is the name of the file input stream class? b. What is the name of the file output stream class? c. To read a number or a string from a file, we must associate the file input stream with an object from what class? d. To write a number or a string to a file, we must associate the file output stream with an object from what class? e. What is the input stream method that obtains the next item in a file? f. This method returns the value of what instance variable if the item is a number? g. This method returns the value of what instance variable if the item is a whitespace-delimited string? h. This method returns the value of what instance variable if there is an attempt to read beyond the end of the file? i. If this method reads a number, the method stores the value in what instance variable? j. If this method reads a string, the method stores the value in what instance variable? k. What output file stream method closes the file?

---

Exceptions
If we know that execution of a method can generate an error, or exception, Java expects that we acknowledge the situation and perhaps handle the exception. We say that the exceptional behavior throws an exception. For example, an error in opening, reading from, or writing to a file is an IOException. More specifically, if a disk file is not found in attempting to instantiate a file stream, a FileNotFoundException is thrown by the statement. IOException and FileNotFoundException are classes, and an exception is an object in such a class.

We can acknowledge that a method, such as main, has the potential of having file difficulties on the first line of the method's definition, as follows:

public static void main(String argv[]) throws IOException
{
	...
}

However, this clause does not instruct the computer about what to do in such exceptional situations. 

A better alternative is to enclose the segment that might result in an error in a try statement and to handle a problem in a catch statement. For example, we enclose the statements from opening the file streams to closing those streams in a try block. Then, after the keyword catch, in parentheses we have an argument of the type of the exception, such as FileNotFoundException, and in brackets how to handle the exception. We have a catch for each exception. The try-catch statements for file processing follow:

try {
	// statements to open, read, and write file stream(s)
	...
}
catch (FileNotFoundException e) {
	System.err.println("main: " + e);
}
catch (IOException e) {
	System.err.println("main: " + e);
}

If the file is not found, a statement with the name of the disk file similar to the following is displayed:

main: java.io.FileNotFoundException: FileIn.dat

As the above segment indicates, we can have more than one catch block, but no statements can appear between the try and the catch blocks. If one catch statement does not catch an error, the next catch attempts to do so. Thus, the order in which we list the catch statements is important. To catch the exception, the type of the argument of the catch statement must match the error. Because FileNotFoundException is a subclass of IOException, if a file is not on a disk, both types would match the exception. An IOException also includes errors in reading from or writing to a file. Table 5 lists some Java exceptions.

Table 5. Some Java exceptions

Exception	Meaning
ArithmeticException	Overflow or integer division by zero
ArrayIndexOutOfBoundException	Array index not in declared range
FileNotFoundException	Disk file not found
IndexOutOfBoundsException	String or array index not in declared range
IOException	Error in dealing with an input/output file stream
NullPointerException	Illegal attempt to use null reference
NumberFormatException	Illegal conversion of String to number

---

Random Numbers

Simulations, such as a simulation of molecules moving in an enclosed area or of weather, require random numbers. Because the class Random is part of the java.util package, we import the package as follows:

import java.util.*; 

or

import java.util.Random;

Table 6 contains a list of some of the methods in the Random class.

The following segment instantiates prob as a Random object and assigns to double variable d a uniformly distributed pseudorandom integer in the interval [0.0, 1.0), numbers greater than or equal to 0.0 and less than 1.0:

Random prob = new Random();
double d = prob.nextdouble(5);  

For example, d might be assigned the value 0.9557053550430712.

To obtain a nonnegative pseudorandom double that is less than 4.0, we multiply the value by 4.0, as follows:

d = prob.nextdouble() * 4.0;

If prob.nextdouble() returns, then d becomes 4.0 times this value, 3.8228214201722848.

If we need a random double greater than or equal to 8 and less than 12, we obtain a random double in the interval [0.0, 1.0). Then, we multiply the result by the length of the interval, 12 - 8 = 4 and add the lower bound (8.0), as follows:

d = prob.nextdouble() * 4.0 + 8.0;

For example, if prob.nextdouble() * 4.0 is 3.8228214201722848, adding 8.0 gives 11.8228214201722848.  

Casting the entire expression on the right to int truncates the floating point number from [8.0, 12.0) to an integer in the set {8, 9, 10, 11}:

int i = (int)(prob.nextdouble() * 4.0 + 8.0);

Because the expression in parentheses returns a floating point number less than 12.0, casting to int yields an integer less than 12. To obtain a pseudorandom integer in the 5-element set {8, 9, 10, 11, 12}, we multiply by 5 = 12 - 8 + 1, as follows:

i = (int)(prob.nextdouble() * 5.0 + 8.0);

We must be careful to place prob.nextdouble() * 5.0 + 8.0 in parentheses for casting. Because nextdouble returns a floating point number in the interval [0.0, 1.0), (int)( prob.nextdouble()) always truncates to zero.

Table 6. Some methods in the Random class. Unless otherwise specified, "random" means "pseudorandom, uniformly distributed."

Method	Meaning
nextDouble()	Returns next "random" double between 0.0 and 1.0
nextFloat()	Returns next "random" float between 0.0 and 1.0
nextGaussian()	Returns next pseudorandom, Gaussian ("normally") distributed double with mean 0.0 and standard deviation 1.0
nextInt()	Returns next "random" int
nextLong()	Returns next "random" long
Random()	Creates random number generator with current time as seed
Random(seed)	Creates random number generator with long seed as seed

Quick Review Question

Quick Review Question 10 Be sure not to include any blanks in your answers. a. What is the name of the class for generation of pseudorandom numbers? b. Suppose rand is an object in this class. Complete the statement to display a uniformly distributed random double between 0.0 and 50.0. System.out.println(rand.   (a)      (b)  50.0); c. Complete the statement to display a uniformly distributed random double between 100.0 and 150.0. System.out.println(rand.   (a)     (b)  50.0  (c)  100.0); d. Suppose rand is an object in this class. Complete the statement to display a uniformly distributed random int between 0 and 50, inclusively (i.e., in the set {0, 1, 2,..., 50}). System.out.println(  (a)   (rand.nextDouble() *  (b) .0)); e. Complete the statement to display a uniformly distributed random double between 100 and 150, inclusively. System.out.println((int) (rand.nextDouble() *   (a)  .0 +   (b) .0));

---

Math Class
Java's java.lang package contains the Math class. Because the compiler automatically loads this package, we do not need to import it. The class contains a number of methods and two constants. Math.PI is p (3.14159…) and Math.E is e (2.71828...) to about 19 decimal places. To invoke a Math method, we use the class name (Math), a dot, and the method name. For example, to assign the absolute value of x, |x|, to Posx, we employ the abs method, as follows:

Posx = Math.abs(x);

Table 7 lists several of the methods and constants in the Math class.

Table 7. Table of several Math class methods and constants, where x and y are of type double unless otherwise noted

Method or Constant	Meaning
abs(x)	Absolute value of x, where x is double, float, int, or long
acos(x)	arccos(x)
asin(x)	arcsin(x)
atan(x)	arctan(x), which is between -p/2 and p/2
atan2(x, y)	arctan(y/x), which is between -p and p
ceil(x)	Ceiling of x, smallest integer greater than or equal to x
cos(x)	cos(x), where x is in radians
E	Constant e
exp(x)	ex
floor(x)	Floor of x, largest integer less than or equal to x
log(x)	ln(x), natural logarithm (log to base e) of x; can throw ArithmeticException
max(x, y)	Maximum of x and y, where x and y are double, float, int, or long
min(x, y)	Minimum of x and y, where x and y are double, float, int, or long
PI	Constant p
pow(x, y)	xy; can throw ArithmeticException
random()	Uniformly distributed pseudorandom double between 0.0 and 1.0
round(x)	Closest long to double x or closest int to float x
sin(x)	sin(x), where x is in radians
sqrt(x)	Square root of x; can throw ArithmeticException
tan(x)	tan(x), where x is in radians

Quick Review Question

Quick Review Question 11 Write expressions for each of the following, using only one blank after each comma and no other blanks: a. cos5(t). b. ln(p z) c.

---

Exercises
1. Write an application program that counts from 1 to 15, printing each number on the same line with a blank between numbers. Advance the output to a new line. Then count backwards by twos to 1, again printing each number on the same line with a blank between numbers. Thus, the output is as follows:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
15 13 11 9 7 5 3 1

2. Develop a program (radius.java) that accepts an integer radius of a circle as a command-line argument and prints the corresponding circumference (2pr) and area (pr²) of the circle, where p is approximately 3.14159. Declare double variables circumference and area. Sample output:

radius of circle = 3
circumference = 18.8495
area = 28.2743

3. Develop a program (BlankBtw.java) that prints the command-line arguments with a blank between each character and two blanks between arguments. For example, if the arguments are

This is a test

The output should be the following:

T h i s  i s  a  t e s t

4. The point class, has private data members x and y. Suppose the constructor below is defined with parameters x and y that should be assigned to the corresponding private data members. How do C++ and Java avoid the ambiguous situation of x or y meaning a parameter and a private data member? Fill in the blanks in the definition of the constructor.

public point(double x, double y) 
{
	______ = x;
	______ = y;
}

5. Write a method GetLine that reads and returns a line from the current position in the input stream f.

6. Write a method to return the reverse of a String argument.

7. Write statements to pad a StringBuffer object s with asterisks to a length of 20. If the string is already of length 20 or more, do nothing.

8. Write a method DeleteAllSub(s, sub) with String parameters to return a String equal to s except omit all occurrences of the substring sub.

9. Write a method DeleteString(s, pos, lng) to return a String object equal to s except to delete from this object the substring starting at position pos for length lng or to the end of the string, whichever occurs first.

10. Write a method subst(s, old, new) with String parameters s, old, and new to return a String object. The return value is the same as s except new is substituted for the first substring old in s. If old cannot be found, a value equal to s is returned.

11. Write a function SequentialSearch with parameters v (a Vector of Strings) and str of type String that performs a sequential search of v and returns the index of the first occurrence of str in v or —1 if str is not in the vector.

12. Write a function BinarySearch with parameters v (a sorted Vector of Strings) and str of type String that performs a binary search of v and returns the index of the first occurrence of str in v or —1 if str is not in the vector.

13. Write a function sort with parameter v, a Vector of Strings, that sorts the vector.

14. Write a method ReplaceChr of an edit class to replace every occurrence of one character in a String with another. For example, if e is an edit object and the string str is "appearance", after execution of the following:

e.ReplaceChr(str, 'a', '*');

the string is "*appe*r*nce".

15. a. Suppose a node class contains data elements for an Object and another node, as follows:

// class for node in queue
class node {
   Object el;
   node next;
}

Develop a dynamic implementation of a stack class with private data member top of type node and with the following methods:

• A default constructor that assigns null to top
• Boolean StackIsEmpty that returns true if the stack is empty
• Boolean StackIsFull that returns false
• MakeNode that returns a node containing an Object parameter
• Push that pushes an Object parameter onto the top of the stack
• Pop that pops and returns the Object from the top of the stack
• RetrieveStack that returns the Object from the top of the stack
• StackError that displays a String error message and aborts the program

      b. Instantiate s to be a stack object.

       c. Suppose a stack contains an integer in the el portion. Write a statement to push 17.3 into s. Use a wrapper.

       d. Suppose val is of type double. Write a statement to pop the top element of s placing the value into val. Be sure to convert the Double to a double.

16. Develop a static implementation of the stack class from the previous exercise using the Vector class.

17. a. Using the node class from Exercise 11, develop a dynamic implementation of a queue class with private data members front and rear of type node and with the following methods:

• A default constructor that assigns null to front
• Boolean QueueIsEmpty that returns true if the queue is empty
• Boolean QueueIsFull that returns false
• MakeNode that returns a node containing an Object parameter
• EnQueue that enqueues an Object parameter onto the rear of the queue
• DeQueue that dequeues and returns the Object from the front of the queue
• RetrieveQueue that returns the Object from the front of the queue
• QueueError that displays a String error message and aborts the program

       b. Instantiate q to be a queue object.

       c. Suppose a queue contains an integer in the el portion. Write a statement to enqueue 5 into q. Use a wrapper.

       d. Suppose val is of type int. Write a statement to dequeue the front element of q placing the value into val. Be sure to convert the Integer to an int.

18. Develop a static implementation of the queue class from the previous exercise using the Vector class.

---

Projects

1. Develop a unit class for conversion between the English and metric systems along with a test program.

2. Develop a fall class with methods concerning a falling object in metric units. The class has private data for initial position and initial velocity, where up is positive. Have the following methods, where s₀ is initial position and v₀ is initial velocity:

• A default constructor that initializes initial position and velocity to zero
• A constructor that initializes initial position and velocity to parameters
• SetInitPosition to establish an initial position
• SetInitVelocity to establish an initial velocity
• WhenMaxPosition to return the time when the object achieves its maximum height. If the object is thrown up, the time is v₀/9.81. If the object is dropped (zero initial velocity) or thrown down (negative initial velocity), the object starts at its high position.
• MaxPosition to return the object's maximum height. If the object is thrown up, the value is . If the object is dropped (zero initial velocity) or thrown down (negative initial velocity), the object starts at its maximum height.
• WhenHitGround to return the time when the object hits the ground, .
• VelocityHitGround to return the velocity () when the object hits the ground

3. Develop a program to simulate a rat pressing a lever. Develop a clock class with the following methods:

• A constructor to initialize the clock to zero
• SetClock to set the time to a parameter value
• GetClock to return the time
• IncrementClock to increment the clock by one unit

Interactively read the length of time for the simulation and the probability (probability) that the rat will press the lever at any one tick of the clock. At each tick, generate a random double between 0.0 and 1.0. If this number is less than probability, write the time to a file.

4. Develop the stack class as described in Exercise 11 and use it to solve the following problem. Some calculators employ a stack and use postfix notation. Design an interactive program to simulate such a calculator. For this machine, the user presses return after entering each number or operation. Numbers are pushed onto the stack. For a binary operator, the top two data items are popped, the operation performed, and the result pushed onto the stack. A unary operator pops the top item, completes the manipulation, and pushes the answer. The simulated calculator should display the top of the stack. The following is part of a sample session with a prompt of > and underlined user input:

> 5
> 7
> *
35
>

The program should accept binary operations of +, -, *, / for floating point division, and ^ for exponentiation. Moreover, it should handle several unary operations, such as sqrt:

> 1.44
> sqrt
1.2
>

Other unary operations to implement are the following: sqr, sin, cos, tan, ln, exp, chs to change the sign, inv to compute the inverse with respect to *, and clear to clear the stack. The operation display prints the stack, and off "turns off" the calculator. If an error occurs, such as an attempt to pop from an empty stack or divide by zero, the "calculator" should print "ERROR."

5. Develop and test the queue class as described in Exercise 13.

---

Copyright © 2002, Dr. Angela B. Shiflet
All rights reserved