netbeans og SavitchIn.java

[krisealv]

Prøvar å få til å kompilere programmet mitt (prosjekt) med lenker til SavitchIn, korleis gjer eg dette, eg plasserer SavitchIn i samme mappe som main.java men får kun

 

init:

deps-jar:

Compiling 2 source files to /home/antikristian/javasource/prosjekt/build/classes

/home/antikristian/javasource/prosjekt/src/prosjekt/SavitchIn.java:15: duplicate class: SavitchIn

public class SavitchIn

/home/antikristian/javasource/prosjekt/src/prosjekt/Main.java:26: cannot access prosjekt.SavitchIn

bad class file: /home/antikristian/javasource/prosjekt/src/prosjekt/SavitchIn.java

file does not contain class prosjekt.SavitchIn

Please remove or make sure it appears in the correct subdirectory of the classpath.

laanebelop = SavitchIn.readLineInt( );

2 errors

BUILD FAILED (total time: 2 seconds)

 

E tidlig i læreprosessen, trenge litt holding i handa her

[slimjim1]

Det ser ut til at du har noe feil med klassen SavitchIn.java

 

Ser ikke ut som du har skrevet den riktig..

Post den evt..

[krisealv]

dette er savitchInIn:

 

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

/**
Class for simple console input.
A class designed primarily for simple keyboard input of the
form one input value per line. If the user enters an improper
input, i.e., an input of the wrong type or a blank line, then
the user is prompted to reenter the input and given a brief
explanation of what is required. Also includes some additional
methods to input single numbers, words, and characters, without
going to the next line.
*/

public class SavitchIn
{
   /**
    Reads a line of text and returns that line as a String
    value. The end of a line must be indicated either by a
    new-line character '\n' or by a carriage return '\r'
    followed by a new-line character '\n'. (Almost all systems
    do this automatically. So you need not worry about this
    detail.) Neither the '\n', nor the '\r' if present, are
    part of the string returned. This will read the rest of a
    line if the line is already partially read.
   */
   public static String readLine( )
   {
       char nextChar;
       String result = "";
       boolean done = false;

       while (!done)
       {
           nextChar = readChar( );
           if (nextChar == '\n')
              done = true;
           else if (nextChar == '\r')
           {
               //Do nothing.
               //Next loop iteration will detect '\n'.
           }
           else
              result = result + nextChar;
       }

       return result;
   }

   /**
    Reads the first string of nonwhitespace characters on
    a line and returns that string. The rest of the line
    is discarded. If the line contains only whitespace,
    the user is asked to reenter the line.
   */
   public static String readLineWord( )
   {
       String inputString = null,
              result = null;
       boolean done = false;

       while(!done)
       {
           inputString = readLine( );
           StringTokenizer wordSource =
                               new StringTokenizer(inputString);
           if (wordSource.hasMoreTokens( ))
           {
               result = wordSource.nextToken( );
               done = true;
           }
           else
           {
               System.out.println(
                    "Your input is not correct. Your input must");
               System.out.println(
                "contain at least one nonwhitespace character.");
               System.out.println(
                                "Please try again. Enter input:");
          }
      }

      return result;
  }

   /**
    Precondition: The user has entered a number of type int
    on a line by itself, except that there may be
    whitespace before and/or after the number.
    Action: Reads and returns the number as a value of type
    int. The rest of the line is discarded. If the input is
    not entered correctly, then in most cases, the user will
    be asked to reenter the input. In particular, this
    applies to incorrect number formats and blank lines.
   */
   public static int readLineInt( )
   {
       String inputString = null;
       int number = -9999;//To keep the compiler happy.
                          //Designed to look like a garbage value.
       boolean done = false;

       while (! done)
       {
           try
           {
               inputString = readLine( );
               inputString = inputString.trim( );
               number = Integer.parseInt(inputString);
               done = true;
           }
           catch (NumberFormatException e)
           {
               System.out.println(
                        "Your input number is not correct.");
               System.out.println(
                        "Your input number must be");
               System.out.println(
                        "a whole number written as an");
               System.out.println(
                         "ordinary numeral, such as 42");
               System.out.println("Minus signs are OK,"
                         + "but do not use a plus sign.");
               System.out.println("Please try again.");
               System.out.println("Enter a whole number:");
           }
       }

       return number;
   }

   /**
    Precondition: The user has entered a number of type long
    on a line by itself, except that there may be whitespace
    before and/or after the number.
    Action: Reads and returns the number as a value of type
    long. The rest of the line is discarded. If the input is
    not entered correctly, then in most cases, the user will
    be asked to reenter the input. In particular, this
    applies to incorrect number formats and blank lines.
   */
   public static long readLineLong( )
   {
       String inputString = null;
       long number = -9999;//To keep the compiler happy.
                     //Designed to look like a garbage value.
       boolean done = false;

       while (! done)
       {
           try
           {
               inputString = readLine( );
               inputString = inputString.trim( );
               number = Long.parseLong(inputString);
               done = true;
           }
           catch (NumberFormatException e)
           {
               System.out.println(
                        "Your input number is not correct.");
               System.out.println(
                            "Your input number must be");
               System.out.println(
                            "a whole number written as an");
               System.out.println(
                             "ordinary numeral, such as 42");
               System.out.println("Minus signs are OK,"
                              + "but do not use a plus sign.");
               System.out.println("Please try again.");
               System.out.println("Enter a whole number:");
           }
      }

       return number;
   }

   /**
    Precondition: The user has entered a number of type
    double on a line by itself, except that there may be
    whitespace before and/or after the number.
    Action: Reads and returns the number as a value of type
    double. The rest of the line is discarded. If the input
    is not entered correctly, then in most cases, the user
    will be asked to reenter the input. In particular, this
    applies to incorrect number formats and blank lines.
   */
   public static double readLineDouble( )
   {
       String inputString = null;
       double number = -9999;//To keep the compiler happy.
                     //Designed to look like a garbage value.
       boolean done = false;

       while (! done)
       {
           try
           {
               inputString = readLine( );
               inputString = inputString.trim( );
               number = Double.parseDouble(inputString);
               done = true;
           }
           catch (NumberFormatException e)
           {
               System.out.println(
                        "Your input number is not correct.");
               System.out.println(
                        "Your input number must be");
               System.out.println(
                         "an ordinary number either with");
               System.out.println(
                          "or without a decimal point,");
               System.out.println("such as 42 or 9.99");
               System.out.println("Please try again.");
               System.out.println("Enter the number:");
           }
       }

       return number;
   }

   /**
    Precondition: The user has entered a number of type float
    on a line by itself, except that there may be whitespace
    before and/or after the number.
    Action: Reads and returns the number as a value of type
    float. The rest of the line is discarded. If the input is
    not entered correctly, then in most cases, the user will
    be asked to reenter the input. In particular,
    this applies to incorrect number formats and blank lines.
   */
   public static float readLineFloat( )
   {
       String inputString = null;
       float number = -9999;//To keep the compiler happy.
                     //Designed to look like a garbage value.
       boolean done = false;

       while (! done)
       {
           try
           {
               inputString = readLine( );
               inputString = inputString.trim( );
               number = Float.parseFloat(inputString);
               done = true;
           }
           catch (NumberFormatException e)
           {
               System.out.println(
                        "Your input number is not correct.");
               System.out.println(
                        "Your input number must be");
               System.out.println(
                         "an ordinary number either with");
               System.out.println(
                         "or without a decimal point,");
               System.out.println("such as 42 or 9.99");
               System.out.println("Please try again.");
               System.out.println("Enter the number:");
           }
       }

       return number;
   }

   /**
    Reads the first nonwhitespace character on a line and
    returns that character. The rest of the line is
    discarded. If the line contains only whitespace, the
    user is asked to reenter the line.
   */
   public static char readLineNonwhiteChar( )
   {
       boolean done = false;
       String inputString = null;
       char nonWhite = ' ';//To keep the compiler happy.

       while (! done)
       {
           inputString = readLine( );
           inputString = inputString.trim( );
           if (inputString.length( ) == 0)
           {
               System.out.println(
                        "Your input is not correct.");
               System.out.println(
                        "Your input must contain at");
               System.out.println(
                        "least one nonwhitespace character.");
               System.out.println("Please try again.");
               System.out.println("Enter input:");
           }
           else
           {
               nonWhite = (inputString.charAt(0));
               done = true;
           }
       }

       return nonWhite;
   }

   /**
    Input should consist of a single word on a line, possibly
    surrounded by whitespace. The line is read and discarded.
    If the input word is "true" or "t", then true is returned.
    If the input word is "false" or "f", then false is
    returned. Uppercase and lowercase letters are considered
    equal. If the user enters anything else (e.g., multiple
    words or different words), the user is asked
    to reenter the input.
   */
   public static boolean readLineBoolean( )
   {
       boolean done = false;
       String inputString = null;
       boolean result = false;//To keep the compiler happy.

       while (! done)
       {
           inputString = readLine( );
           inputString = inputString.trim( );
           if (inputString.equalsIgnoreCase("true")
                  || inputString.equalsIgnoreCase("t"))
           {
               result = true;
               done = true;
           }
           else if (inputString.equalsIgnoreCase("false")
                       || inputString.equalsIgnoreCase("f"))
           {
               result = false;
               done = true;
           }
           else
           {
               System.out.println(
                        "Your input is not correct.");
               System.out.println("Your input must be");
               System.out.println("one of the following:");
               System.out.println("the word true,");
               System.out.println("the word false,");
               System.out.println("the letter T,");
               System.out.println("or the letter F.");
               System.out.println(
                        "You may use either upper-");
               System.out.println("or lowercase letters.");
               System.out.println("Please try again.");
               System.out.println("Enter input:");
           }
        }

       return result;
   }

   /**
    Reads the next input character and returns that character.
    The next read takes place on the same line where this
    one left off.
   */
   public static char readChar( )
   {
       int charAsInt = -1; //To keep the compiler happy.
       try
       {
           charAsInt = System.in.read( );
       }
       catch(IOException e)
       {
           System.out.println(e.getMessage( ));
           System.out.println("Fatal error. Ending program.");
           System.exit(0);
       }

       return (char)charAsInt;
   }

   /**
    Reads the next nonwhitespace input character and returns
    that character. The next read takes place immediately
    after the character read.
   */
   public static char readNonwhiteChar( )
   {
     char next;

     next = readChar( );
     while (Character.isWhitespace(next))
         next = readChar( );

     return next;
   }


   /**
    The following methods are not used in the text, except
    for a brief reference in Chapter 2. No program code uses
    them. However, some programmers may want to use them.
   */


   /**
    Precondition: The next input in the stream consists of
    an int value, possibly preceded by whitespace, but
    definitely followed by whitespace.
    Action: Reads the first string of nonwhitespace characters
    and returns the int value it represents. Discards the
    first whitespace character after the word. The next read
    takes place immediately after the discarded whitespace.
    In particular, if the word is at the end of a line, the
    next read will take place starting on the next line.
    If the next word does not represent an int value,
    a NumberFormatException is thrown.
   */
   public static int readInt( ) throws NumberFormatException
   {
       String inputString = null;
       inputString = readWord( );
       return Integer.parseInt(inputString);
   }

   /**
    Precondition: The next input consists of a long value,
    possibly preceded by whitespace, but definitely
    followed by whitespace.
    Action: Reads the first string of nonwhitespace characters
    and returns the long value it represents. Discards the
    first whitespace character after the string read. The
    next read takes place immediately after the discarded
    whitespace. In particular, if the string read is at the
    end of a line, the next read will take place starting on
    the next line. If the next word does not represent a long
    value, a NumberFormatException is thrown.
   */
   public static long readLong( )
                     throws NumberFormatException
   {
       String inputString = null;
       inputString = readWord( );
       return Long.parseLong(inputString);
   }

  /**
    Precondition: The next input consists of a double value,
    possibly preceded by whitespace, but definitely
    followed by whitespace.
    Action: Reads the first string of nonwhitespace characters
    and returns the double value it represents. Discards the
    first whitespace character after the string read. The
    next read takes place immediately after the discarded
    whitespace. In particular, if the string read is at the
    end of a line, the next read will take place starting on
    the next line. If the next word does not represent a
    double value, a NumberFormatException is thrown.
   */
   public static double readDouble( )
                      throws NumberFormatException
   {
       String inputString = null;
       inputString = readWord( );
       return Double.parseDouble(inputString);
   }

   /**
    Precondition: The next input consists of a float value,
    possibly preceded by whitespace, but definitely
    followed by whitespace.
    Action: Reads the first string of nonwhitespace characters
    and returns the float value it represents. Discards the
    first whitespace character after the string read. The
    next read takes place immediately after the discarded
    whitespace. In particular, if the string read is at the
    end of a line, the next read will take place starting on
    the next line. If the next word does not represent
    a float value, a NumberFormatException is thrown.
   */
   public static float readFloat( )
                        throws NumberFormatException
   {
       String inputString = null;
       inputString = readWord( );
       return Float.parseFloat(inputString);
   }

   /**
    Reads the first string of nonwhitespace characters and
    returns that string. Discards the first whitespace
    character after the string read. The next read takes
    place immediately after the discarded whitespace. In
    particular, if the string read is at the end of a line,
    the next read will take place starting on the next line.
    Note that if it receives blank lines, it will wait until
    it gets a nonwhitespace character.
   */
   public static String readWord( )
   {
       String result = "";
       char next;

       next = readChar( );
       while (Character.isWhitespace(next))
            next = readChar( );

       while (!(Character.isWhitespace(next)))
       {
           result = result + next;
           next = readChar( );
       }

       if (next == '\r')
       {
           next = readChar( );
           if (next != '\n')
           {
               System.out.println("Fatal error in method "
                    + "readWord of the class SavitchIn.");
               System.exit(1);
           }
       }

       return result;
   }

   /**
    Precondition: The user has entered a number of type byte
    on a line by itself, except that there may be whitespace
    before and/or after the number.
    Action: Reads and returns the number as a value of type
    byte. The rest of the line is discarded. If the input is
    not entered correctly, then in most cases, the user will
    be asked to reenter the input. In particular, this applies
    to incorrect number formats and blank lines.
   */
   public static byte readLineByte( )
   {
       String inputString = null;
       byte number = -123;//To keep the compiler happy.
                     //Designed to look like a garbage value.
       boolean done = false;

       while (! done)
       {
           try
           {
               inputString = readLine( );
               inputString = inputString.trim( );
               number = Byte.parseByte(inputString);
               done = true;
           }
           catch (NumberFormatException e)
           {
               System.out.println(
                        "Your input number is not correct.");
               System.out.println(
                        "Your input number must be a");
               System.out.println(
                        "whole number in the range");
               System.out.println("-128 to 127, written as");
               System.out.println(
                        "an ordinary numeral, such as 42.");
               System.out.println("Minus signs are OK,"
                              + "but do not use a plus sign.");
               System.out.println("Please try again.");
               System.out.println("Enter a whole number:");
           }
       }

       return number;
   }

   /**
    Precondition: The user has entered a number of type short
    on a line by itself, except that there may be whitespace
    before and/or after the number.
    Action: Reads and returns the number as a value of type
    short. The rest of the line is discarded. If the input is
    not entered correctly, then in most cases, the user will
    be asked to reenter the input. In particular, this applies
    to incorrect number formats and blank lines.
   */
   public static short readLineShort( )
   {
       String inputString = null;
       short number = -9999;//To keep the compiler happy.
                          //Designed to look like a garbage value.
       boolean done = false;

       while (! done)
       {
           try
           {
               inputString = readLine( );
               inputString = inputString.trim( );
               number = Short.parseShort(inputString);
               done = true;
           }
           catch (NumberFormatException e)
           {
               System.out.println(
                        "Your input number is not correct.");
               System.out.println(
                        "Your input number must be a");
               System.out.println(
                        "whole number in the range");
               System.out.println(
                        "-32768 to 32767, written as");
               System.out.println(
                        "an ordinary numeral, such as 42.");
               System.out.println("Minus signs are OK,"
                              + "but do not use a plus sign.");
               System.out.println("Please try again.");
               System.out.println("Enter a whole number:");
           }
       }

       return number;
   }

   public static byte readByte( ) throws NumberFormatException
   {
       String inputString = null;
       inputString = readWord( );
       return Byte.parseByte(inputString);
   }

   public static short readShort( ) throws NumberFormatException
   {
       String inputString = null;
       inputString = readWord( );
       return Short.parseShort(inputString);
   }

   //The following was intentionally not used in the code for
   //other methods so that somebody reading the code could
   //more quickly see what was being used.
   /**
    Reads the first byte in the input stream and returns that
    byte as an int. The next read takes place where this one
    left off. This read is the same as System.in.read( ),
    except that it catches IOExceptions.
   */
   public static int read( )
   {
       int result = -1; //To keep the compiler happy
       try
       {
           result = System.in.read( );
       }
       catch(IOException e)
       {
           System.out.println(e.getMessage( ));
           System.out.println("Fatal error. Ending program.");
           System.exit(0);
       }
       return result;
   }
}

[slimjim1]

Ser ut som du ikke har med pakke navnet...??

 

Sjekk package i klassene dine.

 

Ser ut som i feilmld at du har lagt den andre klassen i "prosjekt".

 

Legg til dette øvest i class SavitchIn

 

package prosjekt;

 

evt bytt ut med riktig..

[krisealv]

TUSEN takk!!!! Glimrande, sleit dritlenge med den asso:)

[slimjim1]

Så bra da..