News Ticker

Java 3: Werte einlesen, zwischenspeichern und wieder ausgeben

In dieser Ausgabe der Java Artikelserie zeige ich euch wie ihr einen Wert bzw. ein Wort welches ihr in die Konsole eingebt speichert und anschließend wieder ausgebt.
Ein Recht gutes Beispiel hierfür ist das man eine Abfrage des Namens macht.
Die Aufgabenstellung sieht wie folgt aus:

  • Den Benutzer auffordern seinen Namen ein zu geben
  • Den eingegeben Namen in einer Variablen speichern
  • Den gespeicherten Namen in der Konsole ausgeben

Zum einlesen von einem Wert brauchen wir wieder eine neuen Befehl. Dieser lautet.

BufferedReader input=new BufferedReader (new InputStreamReader (System.in)); 
String strInput; 
strInput = input.readLine();

Damit dieser Befehl aber funktioniert muss man das Programm anweisen die bis dahin unbekannten Datentypen “BufferReader” und InputStreamReader” zu Importieren. Dazu fügt ihr unter dem Befehl

package namen_eingabe;

Diese beiden Befehle ein:

import java.io.BufferedReader;
import java.io.InputStreamReader;

Damit das Programm läuft braucht ihr noch eine weitere Anweisung und zwar try und catch. Das ganze ist so aufgebaut.

 try {
// Die Befehlskette welche ausgeführt werden soll.
}
catch (Exception ex) 
{ 
// Wenn irgend etwas schief geht wird diese Operation ausgeführt.
}

Jetzt solltet ihr in der Lage ein Programm zu schreiben wie es oben gewünscht ist.

Euer Fertiges Programm sollte ca. so aussehen:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
 
package namen_eingabe;
import java.io.BufferedReader;
import java.io.InputStreamReader;
 
/**
 *
 * @author Andreas
 */
public class Main {
 
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
              System.out.println("Bitte gebe deinen Namen ein");
              try {
              BufferedReader input=new BufferedReader (new InputStreamReader (System.in));
              String strInput;
              strInput = input.readLine();
              System.out.println("Hallo " +strInput);
              }
              catch (Exception ex)
              { 
              System.out.println("Fehlerhafte Eingabe");
              }
        // TODO code application logic here
    }
 
}

  • In Zeile 7 und 8 werden wie oben beschrieben die 2 Packages importiert.
  • In der Zeile 20 wird einfach eine Ausgabe erstellt damit der Benutzer weiß das er seinen Namen eingeben soll.
  • In der Zeile 21 beginnt der Try Block.
  • Die Zeilen 22 und 24 sind zum Einlesen der Eingabe da.
  • In der Zeile 23 wird die Variable strInput als string definiert, da dieses mal ja Buchstaben eingegeben werden und nicht nur Zahlen wie bei dem Java Tutorial 2.
  • In der Zeile 25 wird der eingegeben Name ausgegeben. Damit in einer Ausgabe Text und Variablen verwendet werden können muss man hinter dem Textbereich welcher ja mit “Text” gekennzeichnet ist ein + vor die Variable setzen.
  • In der Zeile 27 beginnen wir mit dem catch Block.
  • Die Zeile 29 wird ausgeführt wenn in dem Try Bereich ein Fehler aufgetreten ist und man dadurch in den catch Block gelangt. So geben wir dann als Text aus das die Eingabe fehlerhaft war.

Hier geht es zu den bisherigen Teilen der Artikelserie Java:

Java 1: Netbeans die ersten Schritte und Hello World

Java 2: Rechnen mit Variablen

9 Kommentare zu Java 3: Werte einlesen, zwischenspeichern und wieder ausgeben

  1. chris // 23. Jun 2009 um 15:53 //

    Dieses „(…) BufferedReader (new InputStreamReader (…)“ ist ja nicht ohne. Kannst du dir das merken oder wie kommst du damit zurecht? Drei Zeilen plus die Ausgabe… das ist ja auch einiges, wenn du mehrmals etwas einlesen willst oder kann man das vereinfachen?

    In C++:

    /*
    * Programm: HalloName
    */
    
    #include <iostream>
    
    using namespace std;
    
    int main(void) {
            char name;
    
            cout << "Bitte gebe deinen Namen ein: ";
    
            if (cin >> name) {
                    cout << "Hallo " << name << endl;
            } else {
                    cerr << "Fehlerhafte Eingabe!" << endl;
                    cin.clear();
            }
            return 0;
    }
    
  2. Bis auf den Befehl hier geht es.
    BufferedReader input=new BufferedReader (new InputStreamReader (System.in));
    Den kann ich mir auch nicht so merken. den kopiere ich einfach wenn ich ihn brauche. Aber dieser Befehl wird auch nicht einmal benötigt und muss nicht bei jedem einlesen neu erstellt werden.
    Diese beiden befehle gehen ja.
    String strInput;
    strInput = input.readLine();
    Hier wird zuerst nur die Variable als strInput als String deklariert. und danach wird dort dort Inhalt der Eingabe gespeichert.
    Man könnte diese Zeilen auch in einer Zeile zusammen fassen um etwas Code zu sparen das würde dann so aussehen.
    String strInput = input.readLine();
    Hier wird zunächst die Variable deaklriert und gleich danach eingelesen. So spart man sich etwas schreibarbeit. Aber ich dachte so wie es oben beschrieben ist ist es erst einmal etwas übersichtlicher.

  3. Hi,
    etwas eleganter ist es die vom BufferedReader ausgelöste IOException abzufangen anstelle der „universellen Exception“.

  4. Ah ok vielen dank für den Tipp ich mache halt gerade eine Java Grundkurs und möchte die dinge welche ich dort lerne auch im Blog veröffentlichen. Ich denke mal das es am anfang einfacher zum lernen ist mit der universellen exeption und das es später auch noch anders gezeigt wird. Wäre das möglich?
    Ich kann hier bei Java leider auch nur das Wissen weiter geben was ich bis jetzt gelernt habe.

  5. Jö, weiss nicht wo macht du den Grundkurs? Häufig sind „Grundkurse“ sehr oberflächlich. So wird dann oft auch nicht darauf hingewiesen, dass man anstelle des „+“ häufig besser einen StringBuffer verwenden sollte oder das switch case i.d.R. schneller ist als umfangreiche if-else Konstrukte.

    Bezüglich der Exceptions schau dir doch mal diesen Link an, da ist das recht gut erklärt: Sun Java Online Tutorial zu Exceptions.

    Übrigens war mein Kommentar auch nicht als Kritik gemeint, sollte nur ein Hinweis sein. 🙂

  6. Den Kurs mache ich in der Technikerschule in Stuttgart. Es ist ein Vorbereitungskurs für den Techniker so das man schon die Grundlagen von Java kennt wenn man mit der Schule an fängt.

    Deinen Kommentar habe ich auch nicht als Kritik gesehen. Ich bin auf jeden Fall dankbar wenn ich gute Tipps bekomme wie man etwas besser machen kann.

  7. Philipp // 19. Mai 2010 um 14:53 //

    Hey,
    Super der Blog!
    Da die befehle BufferedStreamReader und InputStreamReader nicht selbsterklärend sind würde ich mich drüber freuen wenn du noch hinzufügen könntest was diese eigentlich bedeuten bzw machen.
    LG

  8. Philipp // 19. Mai 2010 um 15:21 //

    BufferedReader input=new BufferedReader (new InputStreamReader (System.in));
    String strInput;
    strInput = input.readLine();

    Hier wird der name gespeichert und zur variable strInput gemacht. Also das passiert hier soweit ich verstanden habe. Aber köntest du ein Diagramm x(speichert name) -> y(ersetzt name durch variable) machen, sodass schritt für schritt nochmal klar wird bei welchem befehl was passiert. Das prinzip hab ich verstanden aber ich möchte so gut wie jedes detail verstehehe.

  9. Eugen // 19. Okt 2011 um 17:03 //

    wieso benutzt man eigentlich nicht einfach die scanner methode ?
    ist viel einfacher und vollkommen unkompliziert:
    import java.util.* ;
    import java.text.*;
    public class Abfrage {

    public static void main(String[] args) {
    String i;
    Scanner sc = new Scanner(System.in);

    System.out.println(„Bitte geben Sie Ihren Namen ein:“);
    i=sc.nextLine();

    System.out.println(„Hallo „+i);

    }}

Kommentare sind deaktiviert.