2. INPUT IN JAVA 1.4

To facilitate input Java provides a "stream" class called BufferedReader to input characters. A class diagram indicating the relationship between this class and some other significant classes (at least in the context of input) is given in Figure 1. Note that all the classes, except the root class, shown in Figure 1 are contained (amongst others) in the java.io package.

The BufferedReader class contains (amongst other things) the methods readLine and read. This first is used to input a line of text (a string), while the second is used to input a single character. In both cases a carriage return is required to signal to the Java interpreter that the input is ready. The input is placed in a temporary storage location called a buffer (something that "buffers" the program from the keyboard in a manner analogous to the way that sets of railway station buffers might be said to "buffer" trains from platforms!); hence the class name BufferedReader.

To use this method we must address two issues:

1. The methods readLine and read are instance methods, thus we require an instance of the BufferedReader class, i.e. a BufferedReader object.
2. We must tell Java what the source of the input stream will be, for example the keyboard, secondary storage, Etc.

To create an instance of a class we require an appropriate constructor. Inspection of the BufferedReader class shows that a constructor of the form:

BufferedReader(Reader in);

is provided. The formal parameter to this constructor, in, is an instance of the class (type) Reader which is a superclass of the class BufferedReader (see Figure 1). This argument is used to tell Java what the source will be. Thus in addition to a BufferedReader object we also need a Reader object. Alternatively from Figure 1 we can see that we can use an InputStreamReader object or a BufferedReader object instead because both are sub-classes of Reader. Remember that through the principle of inheritance an instance of a sub-class is also an instance of all its super classes, therefore we can substitute an inputStreamReader or a bufferedReader object for a reader object. We have already considered the BufferedReader class, any further consideration would simply result in us "going round in circles". However, inspection of the inputStreamReader class indicates the presence of a constructor that has the form:

InputStreamReader(InputStream in)

So now we need an instance of the class InputStream! Because input from the keyboard is such a common requirement Java provides an appropriate predefined InputStream object, called in, for keyboard input. This is a class field (keyword static) contained in the class System contained in the package java.lang (which also contains the object out, the instance of the PrintStream class discussed earlier in the context of output) Remember that the package jaba.lang is always compiled into every Java program. Thus we can create an InputStreamReader object as follows:

InputStreamReader input = 
    new InputStreamReader(System.in)

Note that:

	We have called the instance input (we could have called it anything we liked), we say that the object input is an instance of of (or is of the type InputStreamReader.
	Remember that the keyword new tells the Java compiler to set aside appropriate storage (on the heap) for all the instance fields associated with the class InputStreamReader.
	Remember also that when we refer to a class field from outside its class we must link it to its class using a membership operator, hence System.in.

Now that we have an InputStreamReader object we can create an instance of the class BufferedReader. We will call it keyboardInput:

BufferedReader keyboardInput = 
    new BufferedReader(input);

Alternatively we can combine the two statements as follows:

BufferedReader keyboardInput = 
    new BufferedReader(new 
    InputStreamReader(System.in));

In the second case we create an anonymous object of type InputStreamReader (i.e. one without a name) and consequently our code becomes more succinct but less readable or understandable. Thus, for reasons of readability and understandability we will, for the time being, be adopting the first approach. We can now invoke the readLine method:

keyboardInput.readLine();

This is not quite the end of the story! because although readLine has no formal parameters it returns a string (read from the keyboard) which must be assigned to an appropriately defined variable (data item). We say that the readLine method has a return type of String. Thus we need a variable of type String in which to store the input. A string variable called name would be declared as follows:

String name;

We can now "capture" keyboard input thus:

name = keyboardInput.readLine();

Note: the type String is a predefined compound type. The nature of the type String will be discussed further at a later date.

In Figure 2 the input class diagram given in Figure 1 is combined with the output class diagram presented previously.

Using the above we can extend the Hello World program described earlier so that it takes some input as indicated by the Java code presented in Table 1.

Note that, in the above code, we have expressly imported the java.io package (unlike java.lang this is not included automatically) using an import statement. The '*' symbol is a "wild card" symbol indicating all the classes in the named package. The java compiler will then "compile in" those classes that are referred to our class definition. We could have specified particular classes. For example:

3. WRAPPER CLASSES

In the above example we have shown how we can input a string into a Java program using the readLine method. Input is always in the form of a string; so what if we wish to input (say) an integer or a float? To do this we must convert the string into the appropriate format. Because this is a very common requirement Java provides a mechanism whereby this may be achieved. We use something called a wrapper class. Each of the primitive types char, int, long, float, double, etc. has a corresponding wrapper class associated with it: Character, Integer, Long, Float, Double etc. (note the upper case letter for the first character of each identifier in keeping with the Java class naming convention). These classes are designed to "wrap" the primitive types into a class.

Figure 3: Class diagram showing API classes associated with the Integer wrapper class

In the following subsections we will examine some of the features of these wrapper classes by considering part of the contents of one such class, the Integer class (Figure 3).

Integer.parseInt(s)

$ java IntegerInputApp
Input an integer 23
The value is 23         

java.lang.NumberFormatException: 
	1000000000000
    at java.lang.Integer.
	parseInt(Integer.java)
    at java.lang.Integer.
	< init >(Integer.java)
    at IntegerInputApp.
	main(IntegerInputApp.java:35) 

Note the NumberFormatException (do not worry at this stage if you do not understand all of the resulting output.)

public Integer(String s) throws 
	NumberFormatException;

(Note that this throws an exception called NumberFormatException).

public int intValue();

Each wrapper class also includes a toString method which converts its the value "wrapped" up in the class to a string. This is most commonly used automatically by the Java interpreter when ever it discovers a concatenation operator (+) in an output statement (e.g. print or println).

Remember that the concatenation operator joins strings, however the operands for the operator do not necessarily have to be strings. Where this occurs the Java interpreter will automatically invoke the appropriate toString method --- there is one in each wrapper class. Of course to simply print out only (say) an integer or a double we can use the appropriate print or println defined in the PrintStream and PrintWriter Classes. If we look in these classes we will see that there are print and println methods for each of the primitive types.

Finally it is worth noting the wrapper classes for discrete types (such as the Integer wrapper class) also includes two class constants called MIN_VALUE and MAX_VALUE (see Figure 3). These contain the maximum and minimum value that an discrete type can take, and are useful when checking inputs to ensure that they do not go out of range (more on this later).

4. REFINEMENT OF THE INPUT PROCESS