CSCI 201 Lab 14 -- Input and Output Streams in Java

Introduction

So far this semester, we have learned quite a lot about computer programming and Java. We have learned basic Java program structure, primitive data types, expressions, objects, class libraries, control statements (conditional and iteration statements), instance variables, scope, parameters, returns, object references, interfaces, arrays, vectors, and inheritance. We have also learned how to create Java source code (*.java) files, which incorporate these concepts using a basic Integrated Development Environment (IDE) like JCreator LE .

This has been a lot of difficult material. You should be proud of yourself for making it this far. But, unfortunately, our ability to perform input and output (IO) in Java has been limited to input via the keyboard class and output via simple System.out.println() commands.

In this lab, we will take our knowledge regarding IO in Java to the next level. We will first learn how to write a program which obtains user input from the keyboard without using the keyboard class. This means we will learn how to manipulate Input Streams. Then we will learn how to write a program which sends program output somewhere else (in addition to the display screen), such as a file on a diskette or hard drive. This means we will learn how to manipulate Output Streams.

Part 1: Exceptions

The purpose of this part of the lab is to introduce you to writing programs in Java dealing with Exceptions. This includes Input and Output Streams. To start with, you will write a program that throws an Exception (Doesn't that sound fun!)

Getting Started

If a directory called C:\files\lab14 presently exists on your computer, delete it.
Now, Start JCreator (like you didn't see that one coming).
Then, create an Empty Project and name it Lab14.
Next, add a new Java File and name it Lab14.

Begin your program by typing (or cutting and pasting) the following class outline into Lab14.java.


public class Lab14
{
	public static void main(String[] args)
	{
	}
	
	public static void exceptional(int num) throws GettingUpThereException
	{
	}
}

Now, let's discuss Exceptions a little bit. An Exception is an Object, therefore they can be created at any time. There are different types of exceptions each defined by a different class. You can design your own type of exception, and, as a matter of fact, we will be doing exactly that. After the code you have already typed, enter the following:


class GettingUpThereException extends Exception
{
	GettingUpThereException(String message)
	{
		super(message);
	}
}

What we have done is create a new type of exception that is derived from the parent (i.e., super) class Exception. The definition of the new derived class, GettingUpThereException, is placed within the Lab14 file. Now, we will complete the exceptional() method.

First, create an object of type GettingUpThereException in the exceptional() method. The class constructor requires a String as an argument (i.e., it has a String parameter). Therefore, you will need to pass a String message such as: "Young at heart is a wonderful thing" to the constructor when creating the GettingUpThereException object.
Next, use an if-statement to test whether the argument passed to exceptional() is greater than the number that you consider to be the breaking point to old age. The responsibility of this if-statement is to throw a GettingUpThereException exception if that number is "old".
Finally, enter a System.out.println() statement with a message such as: "You're pretty young" at the end of the exceptional() method.

The final portion of the first part of this lab is to call the exceptional() method from main().

In main(), declare an integer variable.
Then, set up a for-loop that will execute four times. Within this for-loop, the first statement of the for-loop needs to prompt the user for a number.
Next, add Keyboard.java to the Lab14 project, and then use the Keyboard class to read an integer into the variable you created above. This read statement will be the second statement in the for-loop. (Remember, you will also need to import the Keyboard class at the start of Lab14.)
Now for the hard part. As the third statement of the for-loop, you need to call the exceptional() method giving it the number entered by the user as its argument. Since that method throws a GettingUpThereException exception, this will need to be done with try-catch blocks. When you get it done, test it with numbers below and above your "old-age" number. Have Fun!

Lab Check-off 1

When you finish, show your program to your lab instructor.

Part 2: Input Streams

In the second part of this lab, you will learn how to read from the keyboard without the Keyboard class. Sounds fun, huh. Don't worry, it's not all that bad. We proceed by modifying Lab14.java as follows:

To read input from the console, you first need to import java.io.*;.
Now, change the integer variable in main to be a String.
Next, we will create a couple of objects using the first object as an argument to the next. First, at the beginning of main(), create an InputStreamReader object. When creating this object, give the InputStreamReader constructor the System.in object as an argument. (System.in is a InputStream object linked to the keyboard that is instantiated in the java.io package.) Next, create a BufferedReader object giving its constructor the newly created InputStreamReader object as an argument. Our purpose in creating Input Stream objects in this manner is to increase the functionality of the final Input Stream object that is linked to the keyboard. We'll use that object (i.e., the BufferedReader object) to read data from the keyboard.
The BufferedReader class has a method called readLine(), which returns a String value, (the reason we changed our variable to a String). Replace the call to Keyboard.readInt() with a call to the BufferedReader object's readLine() method.
Since we now have a String value instead of an integer, you will need to convert the String to an integer before you pass it to exceptional(). This can be done as following, (assuming you named your String "num"):
```
	exceptional(Integer.parseInt(num));
```
It might seem like a pain to read the input into a String, but it does have some advantages. For instance, now you can change the for loop to a while loop and do something like, while(num.compareToIgnoreCase("Q") != 0) to enable the user to go as long as they would like, but exit by typing the String "Q" whenever they wish.
Compile the project. You should notice an error message saying something like the following, where stdin is the name of the BufferedReader object:
```
C:\files\java\junk\Lab14.java:14: unreported exception java.io.IOException; must be caught or declared to be thrown
		num = stdin.readLine();
```
You need to solve this one on your own, but here's a hint. Java input throws an IOException exception, therefore the function calling it must handle that exception. You can look at the exceptional() method as an example of handling such a situation. The exceptional() method throws a GettingUpThereException exception, and IOException is a different type of exception. But, remember, all exceptions are derived from the Exception class, therefore, any exception can be caught by a catch block with a parameter of type Exception.

Lab Check-off 2

When you get your code running, show it to your lab instructor for credit.

Part 3: Output Streams

As our final modification to Lab14.java, we will write output to a file in addition to the monitor.

First, declare a variable of type PrintWriter.
Next, assign to the PrintWriter variable the address of the new PrintWriter object returned by the following statement, where "out.txt" is the name of the output file (you may use any file name you like):
```
    new PrintWriter(new FileOutputStream("out.txt"));
```
The statement above can throw a FileNotFoundException exception (actually, the FileOutputStream constructor may throw that exception). We must either catch that exception using a try/catch block as we have done in Parts 1 and 2, or we can continue to throw that exception. In this case, we will continue to throw the exception rather than catch it. This means that, should the exception occur, our program will be aborted. To continue to throw this exception out of main() we must modify the header of main() to read as follows:
```
 public static void main(String[] args) throws FileNotFoundException 
```
Now let's write some output to a file via the PrintWriter object. Assuming that the PrintWriter object is named "output," and the variable used to store the user's input is "num." Add the following line of code to the for-loop in main() immediately following the statement that reads the user's input from the keyboard and before the call to exceptional(). This line will echo the user's input to the output file:
```
 
    output.println("You entered the number " + num); 
```
After the for-loop in main(), close the file with the following command, again assuming that "output" is the name of the PrintWriter object.
```
    output.close();
```

Run your program, and check the contents for the designated output file using Windows Explorer. The file will exist in the Lab14 directory but it will not appear in the JCreator FileView.

Lab Check-off 3

When you get your code to write to a file, show it to your lab instructor for credit.