Variablen

Wir haben uns bereits in einem gewissen Maße mit Strings bei der Bearbeitung von Benutzereingaben vertraut gemacht. Wenden wir uns nun anderer Variablen-Typen zu, die in Java häufig verwendet werden.

Eine Variable kann als "Container" betrachtet werden, in dem Informationen eines bestimmten Typs gespeichert werden können. Beispiele für diese verschiedenen Typen sind Text (String), Ganzzahlen (int), Gleitkommazahlen (double) und Wahrheitswerte (boolean). Einer Variablen wird mit dem Gleichheitszeichen (=) ein Wert zugewiesen.

int months = 12;

In der obigen Anweisung wird der Wert 12 einer Ganzzahlvariablen namens months zugewiesen. Die Anweisung könnte gelesen werden als: "Der Variablen months wird der Wert 12 zugewiesen".

Ein Variablenwert kann einem String mit dem +-Zeichen angefügt werden, wie im folgenden Beispiel gezeigt.

String text = "contains text";
int wholeNumber = 123;
double floatingPoint = 3.141592653;
boolean trueOrFalse = true;

System.out.println("Text variable: " + text);
System.out.println("Integer variable: " + wholeNumber);
System.out.println("Floating-point variable: " + floatingPoint);
System.out.println("Boolean: " + trueOrFalse);

Ausgabe:

Variablennamen sind einzigartig - keine zwei Variablen dürfen denselben Namen haben. Das folgende Beispielprogramm ist fehlerhaft, da es versucht, die Variable pi zweimal zu erstellen. Die Variable wird beim ersten Mal erstellt, wenn sie deklariert wird.

public class Example {
    public static void main(String[] args) {
        double pi = 3.14;
        double pi = 3.141592653;

        System.out.println("The value of pi is: " + pi);
    }
}

Der Variablentyp wird angegeben, wenn die Variable erstmals deklariert wird. Wenn ein neuer Wert der Variablen zugewiesen wird, wird der Typ nicht mehr angegeben.

int value = 10;
System.out.println(value);
value = 4;
System.out.println(value);

Ändern eines einer Variablen zugewiesenen Werts

Eine Variable existiert ab dem Moment ihrer Deklaration, und ihr Anfangswert bleibt erhalten, bis ihr ein neuer Wert zugewiesen wird. Sie können den Wert einer Variablen ändern, indem Sie eine Anweisung verwenden, die aus dem Variablennamen, einem Gleichheitszeichen und dem neuen zuzuweisenden Wert besteht. Denken Sie daran, dass der Variablentyp nur bei der ersten Variablendeklaration angegeben wird.

int number = 123;
System.out.println("Der Wert der Variablen ist " + number);

number = 42;
System.out.println("Der Wert der Variablen ist " + number);

Ausgabe:

Sehen wir uns die Ausführung des vorhergehenden Programms Schritt für Schritt an. Wenn eine Variable im Programm zum ersten Mal erscheint, d. h. der Computer (streng genommen: der Compiler bzw. der Parser) sowohl ihren Typ (in diesem Fall int) als auch ihren Namen (in diesem Fall number) erfährt, erstellt der Computer einen 'benannten Container' für die Variable. Dann wird der Wert auf der rechten Seite des Gleichheitszeichens in diesen benannten Container kopiert.

Wann immer im Programm eine Variable mit ihrem Namen referenziert wird - hier möchten wir die Zeichenfolge "Der Wert der Variablen ist " gefolgt vom Wert der number-Variablen ausgeben -, wird ihr Wert aus einem Container abgerufen, der den entsprechenden Namen hat.

Wann immer einer Variablen ein Wert zugewiesen wird (hier number = 42), wird überprüft, ob ein Container mit dem angegebenen Namen bereits existiert. Falls ja, wird ein neuer Wert anstelle des alten Wertes in den Container kopiert, und der alte Wert verschwindet. Falls kein Container mit dem Variablennamen gefunden wird, endet die Programmausführung mit einer Fehlermeldung oder das Programm wird nicht ausgeführt.

Die Variable wird dann erneut mit ihrem Namen im Programm referenziert - hier wollen wir erneut die Zeichenfolge "The value of the variable is " gefolgt vom Wert der number-Variablen ausgeben. Wir fahren normal fort und rufen den Wert von number aus einem Container ab, der seinen Namen trägt.

Am Ende des Programms werden Sie feststellen, dass der ursprüngliche Wert der Variablen verschwunden ist. Eine Variable kann nur einen Wert zu einem Zeitpunkt halten.

Der Typ der Variablen bleibt bestehen

Sobald der Typ einer Variablen deklariert wurde, kann er nicht mehr geändert werden. Zum Beispiel kann einer Variablen des Typs int kein Wahrheitswert (boolean) zugewiesen werden, und einer Variablen des Typs boolean kann kein int-Wert zugewiesen werden.

boolean integerAssignmentWillWork = false;
integerAssignmentWillWork = 42; // Funktioniert nicht

int value = 10;
integerAssignmentWillWork = value; // Das auch nicht

Es gibt jedoch Ausnahmen: Einer Variablen des Typs double kann ein Integer-Wert zugewiesen werden, da Java weiß, wie ein Integer während der Zuweisung in ein double konvertiert wird.

double floatingPoint = 0.42;
floatingPoint = 1; // Funktioniert

int value = 10;
floatingPoint = value; // Funktioniert auch

Ein Gleitkommawert (double) kann jedoch nicht einer Ganzzahlvariable (int) zugewiesen werden. Der Grund dafür ist, dass die Entwickler der Sprache Fehler vermeiden wollen, die zu einem Informationsverlust führen könnten.

int value = 4.2; // Funktioniert nicht

double floatingPoint = 0.42;
value = floatingPoint; // Funktioniert auch nicht

Benennen von Variablen

Das Benennen von Variablen ist ein grundlegender Aspekt bei der Beschreibung eines Programms. Sehen wir uns zwei Beispiele an.

double a = 3.14;
double b = 22.0;
double c = a * b * b;

System.out.println(c);

double pi = 3.14;
double radius = 22.0;
double surfaceArea = pi * radius * radius;

System.out.println(surfaceArea);

Beide der vorhergehenden Beispiele funktionieren auf die gleiche Weise und geben das gleiche Ergebnis aus. Eines davon ist jedoch viel verständlicher. Das Ziel hier ist es, die Fläche eines Kreises zu berechnen. Der Wert von pi wird in der ersten Zeile definiert, der Radius des Kreises in der zweiten und die Oberfläche in der dritten berechnet.

Die Benennung von Variablen ist durch bestimmte Einschränkungen begrenzt.

Variablennamen dürfen keine bestimmten Sonderzeichen enthalten, wie Ausrufezeichen (!). Leerzeichen sind ebenfalls nicht erlaubt, da sie zur Trennung von Befehlen verwendet werden. Anstelle von Leerzeichen wird in Java die CamelCase-Schreibweise verwendet. Hinweis! Der erste Buchstabe eines Variablennamens wird immer klein geschrieben:

int camelCaseVariable = 7;

Zahlen können in einem Variablennamen verwendet werden, solange der Name nicht mit einer Zahl beginnt. Ein Name kann auch nicht nur aus Zahlen bestehen.

int 7variable = 4; // Nicht erlaubt!
int variable7 = 4; // Erlaubt, aber kein beschreibender Variablenname

Ein Variablenname darf nicht bereits in Gebrauch sein. Dazu gehören beispielsweise zuvor im Programm definierte Variablen und in Java bereitgestellte Befehle wie System.out.print und System.out.println.

int System.out.print = 4; // Nicht erlaubt!
int System.out.println = 4; // Nicht erlaubt!

int camelCase = 2;
int camelCase = 5; // Nicht erlaubt - Variable camelCase ist bereits in Gebrauch!

Buchstaben mit diakritischen Zeichen (z. B. die Buchstaben ä und ö im Deutschen) sollten ebenfalls nicht in Variablennamen verwendet werden. Sie können diese Buchstaben durch ihre nicht-diastematischen Äquivalente ersetzen. Zum Beispiel sollten Sie ä -> a und ö -> o konvertieren.

Zulässige Variablennamen

• lastDayOfMonth = 20
• firstYear = 1952
• name = "Essi"

Unzulässige Variablennamen

• letzter Tag des Monats = 20
• 1tag = 1952
• vorsicht! = 1910
• 1920 = 1

Der Typ der Variable gibt mögliche Werte an

Der Typ einer Variablen wird bei der erstmaligen Deklaration angegeben. Zum Beispiel wird eine Variable, die den String "text" enthält, mit der Anweisung String string = "text"; deklariert, und eine Ganzzahl mit dem Wert 42 wird mit der Anweisung int value = 42; deklariert.

Der Typ einer Variablen bestimmt die Art der Werte, die ihr zugewiesen werden können. String-Typen halten Text, int-Typen Ganzzahlen, double Gleitkommazahlen, und boolean-Typen sind entweder true oder false.

Die möglichen Werte eines bestimmten Variablentyps sind somit begrenzt. Zum Beispiel kann ein String keine Ganzzahl enthalten, und ein double kann keinen Booleschen Wert enthalten.

Unterschiedlicher Variablentypen

In den textbasierten Benutzungsoberflächen, die wir in unseren Programmen verwendet haben, wird die Eingabe immer als String gelesen, da der Benutzer seine Eingabe als Text schreibt. Das Lesen von Strings vom Benutzer ist Ihnen an diesem Punkt bereits vertraut - wir tun es mit dem nextLine-Befehl der Scanner-Hilfsmethode.

import java.util.Scanner;

public class Program {

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

        System.out.println("Write text and press enter ");
        String text = scanner.nextLine();
        System.out.println("You wrote " + text);
    }
}

Andere Eingabetypen, wie Ganzzahlen, Gleitkommazahlen und Wahrheitswerte, werden ebenfalls als Text gelesen. Sie müssen jedoch mit Hilfe einiger von Java bereitgestellter Werkzeuge in den Zielvariablentyp umgewandelt werden.

Lesen von Ganzzahlen

Der Befehl Integer.valueOf konvertiert einen String in eine Ganzzahl. Er nimmt den String, der den zu konvertierenden Wert enthält, als Parameter.

String valueAsString = "42";
int value = Integer.valueOf(valueAsString);

System.out.println(value);

Bei Verwendung eines Scanner-Objekts wird das Lesen des Wertes normalerweise direkt in die Typumwandlung eingefügt. Dies geschieht so:

import java.util.Scanner;

public class Program {

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

        System.out.println("Write a value ");
        int value = Integer.valueOf(scanner.nextLine());
        System.out.println("You wrote " + value);
    }
}

Testen Sie die Funktionalität Ihres Programms mit nicht-numerischen Eingaben. Das Programm sollte abstürzen, da es nicht weiß, wie es diese Eingaben in Zahlen umwandeln soll. Wir lernen später, wie man mit solchen Ausnahmesituationen umgeht.

Lesen von Gleitkommazahlen

Der Befehl Double.valueOf konvertiert einen String in eine Gleitkommazahl. Er nimmt den String, der den zu konvertierenden Wert enthält, als Parameter.

String valueAsString = "42.42";
double value = Double.valueOf(valueAsString);
System.out.println(value);

Wie bei Ganzzahlen erfolgt das Lesen direkt in der Umwandlung eingebettet. Dies wird wie folgt durchgeführt:

import java.util.Scanner;

public class Program {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("Write a value ");
        double value = Double.valueOf(scanner.nextLine());
        System.out.println("You wrote " + value);
    }
}

Es ist auch möglich, eine Ganzzahlvariable in ein double einzulesen, in diesem Fall wird der Wert automatisch in den Typ double konvertiert. Das folgende Beispiel zeigt, wie das vorherige Programm funktioniert, wenn der Benutzer eine Ganzzahl eingibt.

Lesen von Wahrheitswerten

Der Befehl Integer.valueOf konvertiert einen String in eine Ganzzahl und Double.valueOf konvertiert ihn in eine Gleitkommazahl. Der Befehl valueOf erscheint auch beim Konvertieren eines Strings in einen Wahrheitswert - dies geschieht mit dem Befehl Boolean.valueOf.

Boolesche Variablen können entweder den Wert true oder false haben. Beim Konvertieren eines Strings in einen Booleschen Wert muss der String "true" sein, wenn wir den Booleschen Wert true haben wollen. Die Groß- und Kleinschreibung spielt hier keine Rolle: sowohl "true" als auch "TRue" werden in den Booleschen Wert true umgewandelt. Alle anderen Strings werden in den Booleschen Wert false umgewandelt.

import java.util.Scanner;

public class program {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("Write a boolean ");
        boolean value = Boolean.valueOf(scanner.nextLine());
        System.out.println("You wrote " + value);
    }
}

Zusammenfassung

Zum Schluss eine Zusammenfassung:

import java.util.Scanner;

public class Program {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String text = scanner.nextLine();
        int integer = Integer.valueOf(scanner.nextLine());
        double floatingPoint = Double.valueOf(scanner.nextLine());
        boolean trueOrFalse = Boolean.valueOf(scanner.nextLine());

        // und so weiter
    }
}