Eingaben lesen

Eingabe bezieht sich auf Text, den die Nutzenden schreiben und der vom Programm gelesen wird. Eingaben werden immer als String gelesen. Zum Lesen der Eingabe verwenden wir das Scanner-Werkzeug (die Scanner-Klasse), das mit Java geliefert wird. Das Werkzeug kann durch das Hinzufügen des Befehls import java.util.Scanner; vor dem Beginn des Hauptprogramms (public class ...) importiert werden. Das Werkzeug selbst wird mit Scanner scanner = new Scanner(System.in); erstellt.

import java.util.Scanner;

public class Program {

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

        // Wir können jetzt das Scanner-Werkzeug verwenden.
        // Dieses Werkzeug wird verwendet, um Eingaben zu lesen.
    }
}

Im Folgenden ist ein Beispiel für ein Programm dargestellt, das nach einer Eingabe der Nutzenden fragt, den eingegebenen String liest und ihn dann ausgibt.

// Das Scanner-Werkzeug für die Eingabelesung einführen
import java.util.Scanner;

public class Program {

    public static void main(String[] args) {
        // Ein Werkzeug zum Lesen von Eingaben erstellen und es "scanner" nennen
        Scanner scanner = new Scanner(System.in);

        // "Write a message: " ausgeben
        System.out.println("Write a message: ");

        // Den vom User eingegebenen String lesen und
        // speichern "String message = (String, der als Eingabe gegeben wurde)"
        String message = scanner.nextLine();

        // Den von den Nutzenden geschriebenen Text ausgeben
        System.out.println(message);
    }
}

Genauer gesagt wird die Eingabe mit der Methode nextLine() des scanner-Werkzeugs gelesen. Der Aufruf scanner.nextLine() wartet darauf, dass der User etwas schreibt. Wenn etwas geschrieben wurde und die Eingabetaste gedrückt wurde, wird der bereitgestellte String einer String-Variablen zugewiesen (in diesem Fall message). Das Programm kann später auf die Variable message zugreifen – im obigen Beispiel wird die Variable message im Ausgabebefehl verwendet.

Wenn das Programm ausgeführt wird, kann die Ausgabe wie im untenstehenden Beispiel aussehen. In diesem Beispiel haben die Nutzenden den Text "Hello world" eingegeben – in den Beispielausgaben ist die Nutzereingabe rot markiert.

Das untenstehende Video zeigt den Prozess der Erstellung eines Programms, das Nutzereingaben liest. Wir werden IntelliJ IDEA nutzen. Sehen Sie sich das Video an, bevor Sie die nächste Programmierübung machen. Achten Sie besonders darauf, wie die Nutzereingabe im Ausgabefenster unten in IntelliJ angezeigt wird, während das Programm ausgeführt wird.

Nun machen wir einen Schritt zurück und betrachten, was String message = ... überhaupt bedeutet.

Grundlagen von Strings

Wie Sie vielleicht bemerkt haben, sprechen wir in der Programmierung von "Strings" statt von "Text". Der Begriff "String" ist eine Kurzform für "Zeichenkette" und beschreibt, wie der Computer Text auf einer grundlegenderen Ebene sieht: als eine Folge von einzelnen Zeichen.

Bisher haben wir Strings auf zwei Arten verwendet. Beim Üben des Ausgabebefehls haben wir den auszugebenden String in Anführungszeichen an den Ausgabebefehl übergeben, und beim Üben des Lesens von Eingaben haben wir den gelesenen String in einer Variablen gespeichert.

In der Praxis sind Variablen "benannte Container", die Informationen eines bestimmten Typs enthalten und einen Namen haben. Eine String-Variable wird in einem Programm deklariert, indem der Typ der Variable (String) und ihr Name (z.B. myString) angegeben werden. Typischerweise wird einer Variablen auch bei ihrer Deklaration ein Wert zugewiesen (die Variable wird dadurch definiert). Sie können einen Wert zuweisen, indem Sie der Deklaration ein Gleichheitszeichen folgen lassen, gefolgt vom Wert und einem Semikolon.

Eine String-Variable namens message, die den Wert "Hello world!" zugewiesen bekommt, wird folgendermaßen deklariert:

String message = "Hello world!";

Wenn eine Variable erstellt wird, steht dem Programm ein spezifischer Speicherplatz zur Verfügung, auf den später verwiesen werden kann. Variablen werden durch ihren Namen referenziert. Zum Beispiel wird eine String-Variable wie unten gezeigt erstellt und ausgegeben:

String message = "Hello world!";
System.out.println(message);

Ein in Anführungszeichen eingeschlossener String in einer Programmiersprache wird als "String-Literal" bezeichnet, d.h. ein String mit einem festgelegten Wert. Ein häufiger Programmierfehler besteht darin, Anführungszeichen um Variablennamen zu setzen. Wenn Anführungszeichen um die String-Variable message gesetzt wären, würde das Programm den Text "message" anstelle des Textes "Hello world!", der in der Variable message gespeichert ist, ausgeben.

String message = "Hello world!";
System.out.println("message");

Konkatenation – Strings miteinander verbinden

Der auszugebende String kann aus mehreren Strings mithilfe des +-Operators gebildet werden. Zum Beispiel gibt das untenstehende Programm "Hello world!" in einer Zeile aus.

public class Program {

    public static void main(String[] args) {
        System.out.println("Hello " + "world!");
    }
}

Auf die gleiche Weise können ein String-Literal und der Wert einer String-Variablen verbunden werden.

public class Program {

    public static void main(String[] args) {
        String message = "Hello world!";

        System.out.println(message + " ... and the universe!");
    }
}

Wir können dasselbe mit beliebig vielen Strings machen.

public class Program {

    public static void main(String[] args) {
        String start = "My name is ";
        String end = ", James Bond";

        System.out.println(start + "Bond" + end);
    }
}

Lesen von Strings

Der Befehl reader.nextLine(); liest die Eingabe und gibt einen String zurück. Wenn wir den String dann im Programm verwenden möchten, muss er in einer String-Variablen gespeichert werden – String message = scanner.nextLine();. Ein in einer Variablen gespeicherter Wert kann wiederholt verwendet werden. Im untenstehenden Beispiel wird die Eingabe zweimal ausgegeben.

//Das Scanner-Werkzeug für die Eingabelesung einführen
import java.util.Scanner;

public class Program {

    public static void main(String[] args) {

        //Das Werkzeug zum Lesen erstellen und dem Variablennamen "scanner" zuweisen
        Scanner scanner = new Scanner(System.in);

        //Eine Nachricht anzeigen "Write a message: "
        System.out.println("Write a message: ");

        //Den eingegebenen String lesen und im Programmspeicher speichern
        //"String message = (Nutzereingabe)"
        String message = scanner.nextLine();

        //Die Eingabe zweimal ausgeben
        System.out.println(message);
        System.out.println(message);
    }
}

Eingabe als Teil der Ausgabe

Wir haben im Beispiel "Hi Ada Lovelace!" festgestellt, dass String-Literale und String-Variablen mithilfe des +-Operators verbunden werden können. Das folgende Beispiel zeigt ein Programm, das Eingaben entgegennimmt und sie mit einem String-Literal ausgibt.

import java.util.Scanner;

public class Program {

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

        System.out.println("Write something: ");

        String message = scanner.nextLine();

        System.out.println("You wrote " + message);
    }
}

Programmausführung wartet auf Eingabe

Wenn die Programmausführung auf eine Anweisung trifft, die versucht, Eingaben zu lesen (der Befehl reader.nextLine()), hält die Ausführung an und wartet. Die Ausführung wird erst fortgesetzt, nachdem die Nutzenden eine Eingabe getätigt und die Eingabetaste gedrückt haben.

Im folgenden Beispiel fordert das Programm auf, drei Strings einzugeben. Zuerst gibt das Programm Write the first string: aus und wartet dann auf die Eingabe. Wenn ein Text eingeben wurde, gibt das Programm Write the second string: aus und wartet erneut auf die Eingabe. Dies wiederholt sich ein drittes Mal, danach gibt das Programm alle drei Strings aus.

import java.util.Scanner;

public class Program {

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

        System.out.println("Write the first string:");
        String first = scanner.nextLine();
        System.out.println("Write the second string:");
        String second = scanner.nextLine();
        System.out.println("Write the third string:");
        String third = scanner.nextLine();

        System.out.println("You wrote:");
        System.out.println(first);
        System.out.println(second);
        System.out.println(third);
    }
}

Im vorherigen Beispiel haben wir die Eingaben in drei verschiedene String-Variablen gespeichert. Dies kann so lange gemacht werden, wie die Variablen unterschiedliche Namen haben (im Beispiel sind die Namen first, second und third).

import java.util.Scanner;

public class Program {

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

        System.out.println("Write the first string:");
        String first = reader.nextLine();
        System.out.println("Write the second string:");
        String second = reader.nextLine();
        System.out.println("Write the third string:");
        String third = reader.nextLine();

        System.out.println("You wrote:");
        System.out.println(first);
        System.out.println(second);
        System.out.println(third);
    }
}

Wir können komplexere Texte erstellen, deren Inhalt sich je nach Eingabe ändert, indem wir mehr Strings verwenden. Im folgenden Beispiel erfahren die Nutzenden ein bisschen mehr über die Texte, die sie geschrieben haben – beachten Sie, dass die Reihenfolge, in der die Strings ausgegeben werden, geändert werden kann. Im Beispiel unten wird der dritte Eingabestring zuerst ausgegeben.

import java.util.Scanner;

public class Program {

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

        System.out.println("Write the first string:");
        String first = reader.nextLine();
        System.out.println("Write the second string:");
        String second = reader.nextLine();
        System.out.println("Write the third string:");
        String third = reader.nextLine();

        System.out.println("Last string you wrote was " + third + ", which ");
        System.out.println("was preceded by " + second+ ".");
        System.out.println("The first string was " + first + ".");

        System.out.println("All together: " + first + second + third);
    }
}