About the Keyboard Class

Some of the examples in our textbook use a class called Keyboard to facilitate keyboard input and simplify early programs. The Keyboard class was designed by the authors of the textbook. It is not part of the Java standard class library. We will use it in all of our assignments from here on out.

package cs1;

//********************************************************************
//  Keyboard.java       Author: Lewis and Loftus
//
//  Facilitates keyboard input by abstracting details about input
//  parsing, conversions, and exception handling.
//********************************************************************

import java.io.*;
import java.util.*;

public class Keyboard 
{
   //*************  Error Handling Section  **************************

   private static boolean printErrors = true;
   private static int errorCount = 0;

   //-----------------------------------------------------------------
   //  Returns the current error count.
   //-----------------------------------------------------------------
   public static int getErrorCount()
   {
      return errorCount;
   }

   //-----------------------------------------------------------------
   //  Resets the current error count to zero.
   //-----------------------------------------------------------------
   public static void resetErrorCount (int count)
   {
      errorCount = 0;
   }

   //-----------------------------------------------------------------
   //  Returns a boolean indicating whether input errors are
   //  currently printed to standard output.
   //-----------------------------------------------------------------
   public static boolean getPrintErrors()
   {
      return printErrors;
   }

   //-----------------------------------------------------------------
   //  Sets a boolean indicating whether input errors are to be
   //  printed to standard output.
   //-----------------------------------------------------------------
   public static void setPrintErrors (boolean flag)
   {
      printErrors = flag;
   }

   //-----------------------------------------------------------------
   //  Increments the error count and prints the error message if
   //  appropriate.
   //-----------------------------------------------------------------
   private static void error (String str)
   {
      errorCount++;
      if (printErrors) 
         System.out.println (str);
   }

   //*************  Tokenized Input Stream Section  ******************

   private static String current_token = null;
   private static StringTokenizer reader;

   private static BufferedReader in = new BufferedReader 
      (new InputStreamReader(System.in));

   //-----------------------------------------------------------------
   //  Gets the next input token assuming it may be on subsequent
   //  input lines.
   //-----------------------------------------------------------------
   private static String getNextToken() 
   {
      return getNextToken (true);
   }

   //-----------------------------------------------------------------
   //  Gets the next input token, which may already have been read.
   //-----------------------------------------------------------------
   private static String getNextToken (boolean skip) 
   {
      String token;

      if (current_token == null)
         token = getNextInputToken (skip);
      else
      {
         token = current_token;
         current_token = null;
      }

      return token;
   }

   //-----------------------------------------------------------------
   //  Gets the next token from the input, which may come from the
   //  current input line or a subsequent one. The parameter
   //  determines if subsequent lines are used.
   //-----------------------------------------------------------------
   private static String getNextInputToken (boolean skip) 
   {
      final String delimiters = " \t\n\r\f";
      String token = null;

      try 
      {
         if (reader == null) 
            reader = new StringTokenizer 
               (in.readLine(), delimiters, true);

         while (token == null || 
                ((delimiters.indexOf (token) >= 0) && skip))
         {
            while (!reader.hasMoreTokens()) 
               reader = new StringTokenizer 
                  (in.readLine(), delimiters,true);
         
            token = reader.nextToken();
         }
      }
      catch (Exception exception) 
      {
         token = null;
      }

      return token;
   }

   //-----------------------------------------------------------------
   //  Returns true if there are no more tokens to read on the
   //  current input line.
   //-----------------------------------------------------------------
   public static boolean endOfLine() 
   {
      return !reader.hasMoreTokens();
   }

   //*************  Reading Section  *********************************

   //-----------------------------------------------------------------
   //  Returns a string read from standard input.
   //-----------------------------------------------------------------
   public static String readString() 
   {
      String str;

      try 
      {
         str = getNextToken(false);
         while (! endOfLine())
         {
            str = str + getNextToken(false);
         }
      }
      catch (Exception exception) 
      {
         error ("Error reading String data, null value returned.");
         str = null;
      }
      return str;
   }

   //-----------------------------------------------------------------
   //  Returns a space-delimited substring (a word) read from
   //  standard input.
   //-----------------------------------------------------------------
   public static String readWord() 
   {
      String token;
      try 
      {
         token = getNextToken();
      } 
      catch (Exception exception) 
      {
         error ("Error reading String data, null value returned.");
         token = null;
      }
      return token;
   }

   //-----------------------------------------------------------------
   //  Returns a boolean read from standard input.
   //-----------------------------------------------------------------
   public static boolean readBoolean() 
   {
      String token = getNextToken();
      boolean bool;
      try
      {
         if (token.toLowerCase().equals("true")) 
            bool = true;
         else if (token.toLowerCase().equals("false")) 
            bool = false;
         else 
         {
            error ("Error reading boolean data, false value returned.");
            bool = false;
         }
      }
      catch (Exception exception)
      {
         error ("Error reading boolean data, false value returned.");
         bool = false;
      }
      return bool;
   }

   //-----------------------------------------------------------------
   //  Returns a character read from standard input.
   //-----------------------------------------------------------------
   public static char readChar() 
   {
      String token = getNextToken(false);
      char value;
      try 
      {
         if (token.length() > 1)
         {
            current_token = token.substring (1, token.length());
         } else
            current_token = null;

         value = token.charAt (0);
      } 
      catch (Exception exception) 
      {
         error ("Error reading char data, MIN_VALUE value returned.");
         value = Character.MIN_VALUE;
      }

      return value;
   }

   //-----------------------------------------------------------------
   //  Returns an integer read from standard input.
   //-----------------------------------------------------------------
   public static int readInt() 
   {
      String token = getNextToken();
      int value;
      try 
      {
         value = Integer.parseInt (token);
      } 
      catch (Exception exception) 
      {
         error ("Error reading int data, MIN_VALUE value returned.");
         value = Integer.MIN_VALUE;
      }
      return value;
   }

   //-----------------------------------------------------------------
   //  Returns a long integer read from standard input.
   //-----------------------------------------------------------------
   public static long readLong() 
   {
      String token = getNextToken();
      long value;
      try 
      {
         value = Long.parseLong (token);
      } 
      catch (Exception exception) 
      {
         error ("Error reading long data, MIN_VALUE value returned.");
         value = Long.MIN_VALUE;
      }
      return value;
   }

   //-----------------------------------------------------------------
   //  Returns a float read from standard input.
   //-----------------------------------------------------------------
   public static float readFloat() 
   {
      String token = getNextToken();
      float value;
      try 
      {
         value = (new Float(token)).floatValue();
      } 
      catch (Exception exception) 
      {
         error ("Error reading float data, NaN value returned.");
         value = Float.NaN;
      }
      return value;
   }

   //-----------------------------------------------------------------
   //  Returns a double read from standard input.
   //-----------------------------------------------------------------
   public static double readDouble() 
   {
      String token = getNextToken();
      double value;
      try 
      {
         value = (new Double(token)).doubleValue();
      } 
      catch (Exception exception) 
      {
         error ("Error reading double data, NaN value returned.");
         value = Double.NaN;
      }
      return value;
   }
}