Wie kann ich eine Eingabe ohne die Klasse Scanner machen?


Sundiego1

Grünschnabel
Hallo,
ich habe eine Aufgabe, dir folgendermaßen lautet:

Nutzen Sie für alle Benutzereingaben die In-Klasse.

Schreiben Sie ein Programm Silvesterfeuerwerk.java, welches überprüft, ob Silvesterfeuerwerk
gezündet werden darf. Implementieren Sie hierbei folgende Regeln:

● Es muss Silvester sein. Sollte dies nicht der Fall sein, so muss eine Sondergenehmigung
vorhanden sein.

● Es existieren die Feuerwerksklassen 1 – 4. Klasse 3 und 4 dürfen nur mit Sondergenehmigung
gezündet werden.
Sollte eines der Kriterien nicht erfüllt worden sein, so darf das Silvesterfeuerwerk nicht gezündet
werden.
Der Nutzer soll folgende Eingaben machen: den Zustand ob Silvester ist, die Feuerwerksklasse (1-4)
sowie die Zustände „Sondergenehmigung Tag vorhanden“ und „Sondergenehmigung Feuerwerk
vorhanden“ eingeben. Auf der Konsole soll ausgegeben werden, ob das Silvesterfeuerwerk gezündet
werden darf.

Ich weiß ungefähr, wie ich vorgehen möchte. Nur da ich diese In-Klasse benutzen soll weiß ich nicht, wie man eine Eingabeforderung macht. Könnt Ihr vielleicht Helfen? Sorry, vielleicht ist es ganz einfach, bin noch Anfänger.

Die In-Klasse:
Java:
import java.io.*;
import java.util.*;
import java.math.*;

public class In {

/** Diese Klasse stellt einige einfache Methoden zum Einlesen von der Tastatur
zur Verfügung. Es werden diverse Werte von der Tastatur eingelesen, die
jeweils durch ein Leerzeichen, einen Tabstop oder ein Zeilenendezeichen
getrennt sein müssen.
@author Jens Scheffler
@version 1.01 Spezialfassung f&uuml;r <I>Programmieren 1 in Java</I>
*/

    private In(){} // somit kann die Klasse nicht instanziiert werden!
    private static BufferedReader in =
               new BufferedReader(new InputStreamReader(System.in));
    private static StringTokenizer eingabe;
    private static String zeichenkette;

/** L&ouml;scht alles, was sich in der momentanen Zeile befindet.
Das hei&szlig;t es wird der Eingabe bis zum Zeilenende keine Beachtung mehr
geschenkt
*/
    public static void flush(){
        eingabe=null;
    }

/* Private Methode, die den Tokenizer fuellt. Dies ist uebrigens eine von
zwei Methoden, die die Klasse zum Absturz bringen kann...*/
    private static void init(){
      zeichenkette=null;
      if (eingabe!=null && eingabe.hasMoreTokens()) return;
        while (eingabe==null || !eingabe.hasMoreTokens())
          eingabe=new StringTokenizer(readLine());
    }

/* Private Methode, die eine Fehlermeldung ausgibt */
    private static void error(Exception e,String prompt) {
      System.out.println("Eingabefehler "+e);
      System.out.println("Bitte Eingabe wiederholen...");
      System.out.print(prompt);
    }

/** Liest eine ganze Textzeile von der Tastatur ein. Soll vorher eine
Eingabeaufforderung gemacht werden, geschieht dies durch den Parameter.
Dieser kann jedoch auch wegfallen.
@param prompt eine eventuelle Eingabeaufforderung
@return die eingelesene Zeile.
*/
/* Dies ist die zweite Methode, die die Klasse zum Absturz bringen kann.*/
    public static String readLine(String prompt){
        flush();
        String erg="";
        System.out.print(prompt);
        try{
            erg=in.readLine();
        } catch(IOException e){
            System.err.println(""+e+"\n Programm abgebrochen...\n");
            //System.exit(1);
        }
        if (erg==null) {
          System.err.println("Dateiende erreicht.\nProgramm abgebrochen...\n");
          //System.exit(1);
        }
        return erg;
    }

/** Liest eine <CODE>int</CODE>-Zahl von der Tastatur ein. Soll vorher eine
Eingabeaufforderung gemacht werden, geschieht dies durch den Parameter.
Dieser kann jedoch auch wegfallen.
@param prompt eine eventuelle Eingabeaufforderung
@return die eingelesene Zahl.
*/
    public static int readInteger(String prompt){
        int erg;
        System.out.print(prompt);
        init();
        while(true){
            try{
                erg=Integer.parseInt(eingabe.nextToken());
            } catch (NumberFormatException e) {
              error(e,prompt);init();continue;
            }
            return erg;
        }
    }

/** Liest eine <CODE>long</CODE>-Zahl von der Tastatur ein. Soll vorher eine
Eingabeaufforderung gemacht werden, geschieht dies durch den Parameter.
Dieser kann jedoch auch wegfallen.
@param prompt eine eventuelle Eingabeaufforderung
@return die eingelesene Zahl.
*/
    public static long readLong(String prompt){
        long erg;
        System.out.print(prompt);
        init();
        while(true){
            try{
                erg=Long.parseLong(eingabe.nextToken());
            } catch (NumberFormatException e) {error(e,prompt);init();continue;}
            return erg;
        }
    }

/** Liest eine <CODE>double</CODE>-Zahl von der Tastatur ein. Soll vorher eine
Eingabeaufforderung gemacht werden, geschieht dies durch den Parameter.
Dieser kann jedoch auch wegfallen.
@param prompt eine eventuelle Eingabeaufforderung
@return die eingelesene Zahl.
*/
     public static double readDouble(String prompt){
        double erg;
        System.out.print(prompt);
        init();
        while(true){
            try{
                erg=Double.valueOf(eingabe.nextToken()).doubleValue();
            } catch(NumberFormatException e) {error(e,prompt);init();continue;}
            return erg;
        }
    }

/** Liest eine <CODE>float</CODE>-Zahl von der Tastatur ein. Soll vorher eine
Eingabeaufforderung gemacht werden, geschieht dies durch den Parameter.
Dieser kann jedoch auch wegfallen.
@param prompt eine eventuelle Eingabeaufforderung
@return die eingelesene Zahl.
*/
    public static float readFloat(String prompt){
        float erg;
        System.out.print(prompt);
        init();
        while(true){
            try{
                erg=Float.valueOf(eingabe.nextToken()).floatValue();
            } catch(NumberFormatException e) {error(e,prompt);init();continue;}
            return erg;
        }
    }

/** Liest eine <CODE>short</CODE>-Zahl von der Tastatur ein. Soll vorher eine
Eingabeaufforderung gemacht werden, geschieht dies durch den Parameter.
Dieser kann jedoch auch wegfallen.
@param prompt eine eventuelle Eingabeaufforderung
@return die eingelesene Zahl.
*/
    public static short readShort(String prompt){
        short erg;
        System.out.print(prompt);
        init();
        while(true){
            try{
                erg=Short.valueOf(eingabe.nextToken()).shortValue();
            } catch(NumberFormatException e) {error(e,prompt);init();continue;}
            return erg;
        }
    }

/** Liest einen boolschen Wert von der Tastatur ein. Soll vorher eine
Eingabeaufforderung gemacht werden, geschieht dies durch den Parameter.
Dieser kann jedoch auch wegfallen.
@param prompt eine eventuelle Eingabeaufforderung
@return der eingelesene Wert.
*/
    public static boolean readBoolean(String prompt){
        String try_this=readString(prompt);
        while (!try_this.equals("true") && !try_this.equals("false"))
            try_this=readString();
        return try_this.equals("true");
    }

/** Liest ein Textwort von der Tastatur ein. Soll vorher eine
Eingabeaufforderung gemacht werden, geschieht dies durch den Parameter.
Dieser kann jedoch auch wegfallen.
@param prompt eine eventuelle Eingabeaufforderung
@return das eingelesene Wort.
*/
    public static String readString(String prompt){
        System.out.print(prompt);
        init();
        return eingabe.nextToken();
    }

    /** Liest ein Zeichen von der Tastatur ein. Soll vorher eine
Eingabeaufforderung gemacht werden, geschieht dies durch den Parameter.
Dieser kann jedoch auch wegfallen.
@param prompt eine eventuelle Eingabeaufforderung
@return das eingelesene Zeichen.
*/
    public static char readChar(String prompt){
        char erg;
        System.out.print(prompt);
        if (zeichenkette==null || zeichenkette.length()==0)
          zeichenkette=readString("");
        erg=zeichenkette.charAt(0);
        zeichenkette=(zeichenkette.length()>1)?zeichenkette.substring(1):null;
        return erg;
    }

/** Liest eine ganze Textzeile von der Tastatur ein.
@return die eingelesene Zeile.
*/
    public static String readLine(){
        return readLine("");
    }

/** Liest eine <CODE>int</CODE>-Zahl von der Tastatur ein.
@return die eingelesene Zahl.
*/
    public static int readInteger(){
            return readInteger("");
    }

/** Liest eine <CODE>int</CODE>-Zahl von der Tastatur ein.
@return die eingelesene Zahl.
*/
    public static int readInt(){
            return readInteger("");
    }

/** Liest eine <CODE>int</CODE>-Zahl von der Tastatur ein. Soll vorher eine
Eingabeaufforderung gemacht werden, geschieht dies durch den Parameter.
Dieser kann jedoch auch wegfallen.
@param prompt eine eventuelle Eingabeaufforderung
@return die eingelesene Zahl.
*/
    public static int readInt(String prompt){
            return readInteger(prompt);
    }

/** Liest eine <CODE>long</CODE>-Zahl von der Tastatur ein.
@return die eingelesene Zahl.
*/
    public static long readLong(){
            return readLong("");
    }

/** Liest eine <CODE>double</CODE>-Zahl von der Tastatur ein.
@return die eingelesene Zahl.
*/
    public static double readDouble(){
        return readDouble("");
    }

/** Liest eine <CODE>short</CODE>-Zahl von der Tastatur ein.
@return die eingelesene Zahl.
*/
    public static short readShort(){
        return readShort("");
    }

/** Liest eine <CODE>float</CODE>-Zahl von der Tastatur ein.
@return die eingelesene Zahl.
*/
    public static float readFloat(){
        return readFloat("");
    }

/** Liest ein Zeichen von der Tastatur ein.
@return das eingelesene Zeichen
*/
    public static char readChar(){
      return readChar("");
    }
   
/** Liest ein Textwort von der Tastatur ein.
@return das eingelesene Wort.
*/
    public static String readString(){
        return readString("");
    }

    /** Liest einen boolschen Wert von der Tastatur ein.
@return das eingelesene Wort.
*/
    public static boolean readBoolean(){
        return readBoolean("");
    }

    /** Wandelt eine double-Zahl in einen String um.
     Bei der &uuml;blichen Umwandlung von double-Werten in einen String
     findet eine Rundung statt. So wird etwa die Zahl 0.1, obwohl intern
     nicht darstellbar, dennoch auf dem Bildschirm ausgegeben. Diese
     Methode umgeht die Rundung */
    public static String toString(double d) {
      if (Double.isInfinite(d) || Double.isNaN(d))
        return ""+d;
      return (new BigDecimal(d)).toString();
    }

    /**
     * Setzt den Standard-Inputreader auf neuen Eingabestrom
     * @param in inputstream instance, not null
     */
    public static void setInputStream(InputStream in) {
        if (in == null)
            throw new IllegalArgumentException("in darf nicht null sein.");
        In.in = new BufferedReader(new InputStreamReader(in));
    }

    /**
     * Setzt den Standard-Inputreader auf neuen Eingabestrom
     * @param in reader instance, not null
     */
    public static void setInputStreamReader(Reader in) {
        if (in == null)
            throw new IllegalArgumentException("in darf nicht null sein.");

        In.in = new BufferedReader(in);
    }

    /**
     * Setzt den Standard-Inputreader auf neuen Eingabestrom
     *
     * @deprecated
     * @param bin   BufferedReader
     */
    public static void setReader (BufferedReader bin) {
        if (bin == null)
            throw new IllegalArgumentException("bin darf nicht null sein.");

        In.in = bin;
 
Zuletzt bearbeitet von einem Moderator:

Bratkartoffel

gebratene Kartoffel
Premium-User
Hi Sundiego1,

bitte den Code immer in Code-Tags packen, so bleibt er lesbar:
[code=java]Hier der code[/code]

Kannst du bitte deinen Beitrag editieren und das so machen?

Grüsse und Danke,
BK
 

ikosaeder

Teekannen-Agnostiker
Ich habe nicht viel Ahnung von Java aber grundsätzlich möchtest du etwas in der Art haben:
variable= Eingabe
In deinem Fall zum Beispiel
Code:
int feuerwerksklasse=In.readInt("Geben sie die Klasse des Feuerwerks an.:");