Klavyeden veri girişi class dosyası java

//********************************************************************
//  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;
   }
}