Variablen, Datentypen und Rechnen in Java

Worum geht´s?

In diesem Java Tutorial werden wir uns erste Variablen und einfachen Datentypen anschauen. Außerdem werden wir lernen, wie wir in Java mit Variablen und arithmetischen Operatoren rechnen können.

1. Was ist eine Variable in Java?

Eine Variable in Java ist zuallererst in etwa das Gleiche wie eine Variable aus dem Mathematik-Unterricht in der Schule.

Vorstellen kannst du dir eine Variable ähnlich wie eine Kiste:

Eine Variable hat dabei mindestens 2 Eigenschaften:

• Variablen-Name: Die „Beschriftung“ der Kiste, ein eindeutiger, sich nicht ändernder Name einer Variable.
• Variablen-Wert: Der „Inhalt“ der Kiste, der sich auch mit der Zeit ändern kann.

In manchen Programmiersprachen (wie in unserem Fall Java) gibt es zusätzlich noch:

• Variablen-Datentyp: Welche Art von Inhalt darf in die Kiste? Dürfen Zahlen rein, Buchstaben, ganze Sätze, …?

Eine Variable kann im Lauf des Programms zu verschiedenen Zeitpunkten unterschiedliche Variablen-Werte besitzen. So kann sie z.B. zum Start des Programms den Wert 3 haben, aber einige Zeilen später auf den Wert 5 geändert werden.

Was sich niemals verändert, ist der Variablen-Name. Er dient zum Wiederfinden der „richtigen Kiste“, wenn wir eine bestimmte Variable auswählen wollen. Deswegen darf ein Variablen-Name auch nur 1x im selben Bereich (durch {}-Klammern begrenzt) vorkommen.

2. Eine Variable in Java anlegen

Wollen wir in Java eine Variable anlegen, so müssen wir sie deklarieren. Das bedeutet, eine Kiste erschaffen wird, die mit einem bestimmten Namen beschriftet wird. Zusätzlich wird über den Datentyp definiert, was später rein darf und was nicht. Das geht in Java z.B. für eine ganzzahlige Zahl so:

public class HelloWorld {
    public static void main(String[] args) {
        int a2;
    }
}

Alles, was mit Variablen zu tun hat, musst du (für den Anfang) innerhalb unserer Main-Methode einfügen.

Nun haben wir zwar eine Kiste mit dem Namen „a2“ geschaffen und bestimmt, dass nur ganzzahlige Zahlen rein dürfen, aber sie hat noch keinen Inhalt.

Deswegen müssen wir sie als nächstes initialisieren. Das bedeutet, sie zum ersten Mal mit einem Inhalt (Wert) zu befüllen:

public class HelloWorld {
    public static void main(String[] args) {
        int a2;
        a2 = 3;
    }
}

Wollen wir das Ganze etwas abkürzen, können wir das Deklarieren und Initialisieren auch in einen Befehl zusammenführen:

public class HelloWorld {
    public static void main(String[] args) {
        int a2 = 3;
    }
}

3. Eine Variable in Java in der Konsole ausgeben

Um eine Variable auszugeben, müssen wir sie wie bei unserem „Hello World!“ Text in den Befehl System.out.println() hineinschreiben:

public class HelloWorld {
    public static void main(String[] args) {
        int a2 = 3;
        System.out.println(a2);
    }
}

Anstatt also die Zahl 3 (den Wert der Variable a2) direkt in unser System.out.println() zu schreiben, schreiben wir stattdessen den Namen der Variable a2.

Sobald der System.out.println(a2)-Befehl aufgerufen wird, überprüft Java, ob es eine Variable (Kiste) mit dem Namen „a2“ gibt. Wenn ja, schaut Java in die Kiste und findet heraus, was drin steht – in unserem Fall 3. Deswegen wird in der Konsole auch die Zahl 3 ausgegeben.

4. Verschiedene Datentypen für Variablen festlegen

Auch wenn es theoretisch unendlich viele Datentypen in Java gibt, kann man die wichtigsten trotzdem auf nur 5 reduzieren:

• int: ganzzahlige Zahlen, z.B.: 3, -302 (inklusive Minus-Zahlen!)
• double: Kommazahlen, z.B. 0.99, -91.99132 (Achtung: Punkt statt Beistrich fürs Komma!)
• char: ein einzelnes Zeichen, z.B. ‚w‘, ‚#‘ oder auch ‚3‘
• String: mehrere Zeichen, z.B. „Niklas“ oder „Ich bin motiviert“ bis zu ganzen Büchern
• boolean: nur 2 Werte, true oder false

Achtung: Nur bei String und char machst du Anführungs-Striche um den jeweiligen Wert, also doppelte bei „Niklas“ bzw. einfache bei ‚w‘. Die doppelten Anführungsstriche machst du auf der deutschen Tastatur mit SHIFT+2, die einfachen mit SHIFT+#.

Das Anlegen von Variablen dieser fünf Datentypen funktioniert dabei genau gleich wie mit dem int-Datentyp von weiter oben:

Datentyp Variablen-Name = Wert;

Auch die Ausgabe mit System.out.println() funktioniert genau gleich.

Hier ein Beispiel für die 5 Datentypen:

public class HelloWorld {
    public static void main(String[] args) {
        int a2 = 3;
        double preis = 2.99;
        char geschlecht = 'w';
        String wohnort = "Steyr";
        boolean betrunken = true;
        
        System.out.println(a2);
        System.out.println(preis);
        System.out.println(geschlecht);
        System.out.println(wohnort);
        System.out.println(betrunken);
    }
}

5. Variablen nach dem Initialisieren verändern

Wenn eine Variable bereits existiert und schon einen Variablen-Wert hat, kann sie zu einem späteren Zeitpunkt verändert werden.

Stell dir dabei der Einfachheit halber vor, dass eine jede Zeile in deinem Source-Code ein eigener Zeitpunkt ist.

Eine Variable kann zwar nie 2 Werte zur gleichen Zeit haben, aber sehr wohl z.B. den Wert 3 in Code-Zeile 4 und später, in Code-Zeile 9 dann den Wert 6.

Du veränderst den Wert einer Variable mit Hilfe einer Zuweisung. Dazu schreibst du den Namen der Variable (ohne Datentyp!), dann ein =-Zeichen und dann den neuen Wert:

Variablen-Name = Wert;

Im folgenden Code wird in Zeile 4 der Wert 5 für die Variable a2 ausgegeben. Da sich der Wert der Variable a2 aber eine Zeile später mit Hilfe einer Zuweisung auf 76 verändert, wird in Zeile 4 daraufhin die Zahl 76 für a2 ausgegeben:

public class HelloWorld {
    public static void main(String[] args) {
        int a2 = 5;
        System.out.println(a2);
        a2 = 76;
        System.out.println(a2);
    }
}

Wenn du das Programm starten würdest, würde in der Konsole Folgendes stehen:

4
76

Da sich in Java Datentypen nach dem Deklarieren nicht mehr ändern dürfen, ist es nicht notwendig (sogar falsch!), wenn du für eine Zuweisung den Datentyp nochmal zur Variable dazuschreibst.

Du bestimmst den Datentyp einer Variable also nur 1x – beim Deklarieren.

6. Mit Variablen rechnen mit Hilfe arithmetischer Operatoren

Arithmetische Operatoren sind im großen und Ganzen nicht mehr als die bereits aus der Volksschule bekannten +, -, *, /, mit einigen kleinen Extras.

Mit Variablen lässt sich in Java (genau wie mit Zahlen) sehr gut rechnen:

public class HelloWorld {
    public static void main(String[] args) {
        int x = 3;
        int y = 2;
        int z = x + y;
        System.out.println(z);
    }
}

Hier wird das Ergebnis der Addition, also 5, in der Variable z gespeichert und dann dieses Ergebnis, nämlich 5, in der Konsole ausgegeben.

Wenn wir das Ergebnis nicht speichern wollen, können wir das Programm auch vereinfachen und die Rechnung direkt in unser System.out.println() einfügen:

public class HelloWorld {
    public static void main(String[] args) {
        int x = 3;
        int y = 2;
        System.out.println(x + y);
    }
}

Dasselbe funktioniert auch mit den Operatoren +, * und /:

public class HelloWorld {
    public static void main(String[] args) {
        int x = 3;
        int y = 2;
        System.out.println(x + y);
        System.out.println(x - y);
        System.out.println(x * y);
        System.out.println(x / y);
    }
}

Es gibt nur ein Problem: Das Ergebnis der Division ist leider nur 1 statt 1,5.

Das liegt daran, dass es sich um eine Division zwischen zwei int-Variablen handelt, und int-Variablen ja bekanntlich ganze Zahlen ohne Komma sind. In diesem Fall geht Java davon aus, dass auch das Ergebnis ohne Komma sein sollte.

Du kannst dir das so vorstellen, dass Java dabei nicht abrundet, sondern eine Art „Volksschul-Division“ macht, also

3:2 = 1
1 Rest

und den Rest einfach ignoriert.

Willst du, dass bei der Division 1,5 rauskommt, muss also mindestens einer der beiden Variablen zum Datentyp double werden:

public class HelloWorld {
    public static void main(String[] args) {
        double x = 3;
        int y = 2;
        System.out.println(x + y);
        System.out.println(x - y);
        System.out.println(x * y);
        System.out.println(x / y);
    }
}

Jetzt bekommen wir zwar korrekterweise unser 1,5 bei der Division raus, aber alle Ergebnisse sind jetzt vom Datentyp double und werden mit .0 hinten angezeigt.

Um das zu vermeiden, können wir auch einen sogenannten typecast verwenden. Ein typecast ändert den Datentyp einer Variable nur für eine bestimmte Rechnung in einen anderen. Es wird also in unserem Fall so getan, als wäre die Variable x vom Datentyp double, ohne sie dauerhaft zu verändern:

public class HelloWorld {
    public static void main(String[] args) {
        int x = 3;
        int y = 2;
        System.out.println(x + y);
        System.out.println(x - y);
        System.out.println(x * y);
        System.out.println( (double)x / y);
    }
}

Nun fehlt uns nur noch ein arithmetischer Operator: %

Das Prozent-Zeichen hat mit Prozent-Rechnen nichts zu tun, sondern steht für „modulo“, oder kurz „mod“. Damit wird der Rest der Division berechnet – in unserem Fall also 1:

public class HelloWorld {
    public static void main(String[] args) {
        int x = 3;
        int y = 2;
        System.out.println(x % y);
    }
}

Der Modulo-Operator ist beim Programmieren manchmal sehr nützlich. So kann man etwa mit dem Modulo-Operator herausfinden, ob eine Zahl n eine gerade Zahl ist. Ist n%2==0, dann ist es eine gerade Zahl.

Es gibt noch viele Anwendungs-Bereiche, aber die wirst du später noch herausfinden.

7. Variablen dauerhaft erhöhen oder verringern

Mit Hilfe einer Zuweisung können wir Variablen auf bestimmte neue Werte setzen.

Es gibt aber auch einen Sonderfall: Eine Variable basierend auf dem bestehenden Wert derselben Variable um einen bestimmten Wert zu verändern.

Wenn also z.B. die Variable x anfangs 3 ist, so soll sie basierend auf diesem Startwert um 4 erhöht werden.

Theoretisch könnten wir das so lösen, dass wir die Variable später einfach auf 7 setzen. Wir sind ja gute Kopfrechner:

public class HelloWorld {
    public static void main(String[] args) {
        int x = 3;
        System.out.println(x);
        x = 7;
        System.out.println(x);
    }
}

Was aber, wenn sich der Startwert von x nun ändert? Dann müssten wir für jede Änderung des Startwerts händisch neu berechnen, was dann der neue Zielwert wäre. Irgendwie unpraktisch.

Deswegen ist es auch möglich, Variablen basierend auf anderen Variablen (oder sich selbst) neue Werte zuzuweisen:

public class HelloWorld {
    public static void main(String[] args) {
        int x = 3;
        System.out.println(x);
        x = x + 4;
        System.out.println(x);
    }
}

Das funktioniert, weil Java als erstes immer die rechte Seite vom =-Zeichen berechnet.

Es wird also in diesem Fall von Java in der Kiste namens x nachgeschaut, welcher Wert drin steht, nämlich 3, dann 4 dazugezählt, womit wir auf 7 kommen, und das Ergebnis dann in x gespeichert.

Wird etwas zu einer bestehenden Variable dazugezählt, lässt sich das Ganze auch etwas kürzer schreiben, indem wir += verwenden:

public class HelloWorld {
    public static void main(String[] args) {
        int x = 3;
        System.out.println(x);
        x += 4;
        System.out.println(x);
    }
}

Das gleiche funktioniert auch mit -=, *= oder auch /=:

public class HelloWorld {
    public static void main(String[] args) {
        int x = 3;
        System.out.println(x);
        x += 4;
        x *= 2;
        x -= 2;
        x /= 2;
        System.out.println(x);
    }
}

Falls nur die Zahl 1 hinzugefügt oder abgezogen werden soll, gibt es sogar eine noch kürzere Schreibweise, nämlich ++ bzw. –:

public class HelloWorld {
    public static void main(String[] args) {
        int x = 3;
        System.out.println(x);
        x++;
        System.out.println(x);
        x--;
        System.out.println(x);
    }
}

Was aber, wenn wir die ++-Schreibweise innerhalb eines System.out.println() oder auch innerhalb einer Rechnung verwenden? Woher weiß Java dann, ob er zuerst den Wert in der Kiste erhöhen und dann ausgeben soll, bevor der Wert erhöht wird, oder ob er zuerst erhöhen soll und dann ausgeben?

Die Antwort liegt in der Positionierung des ++ bzw. des –.

public class HelloWorld {
    public static void main(String[] args) {
        int x = 3;
        System.out.println(x++);
        System.out.println(x);
    }
}

Der obige Code gibt die Zahlen 3 und 4 aus. Im ersten System.out.println() wird das x zwar auf 4 erhöht, aber erst nachdem der ursprüngliche 3er ausgegeben wurde.

Wollen wir diese Reihenfolge ändern, müssen wir das ++ vor dem Variablen-Namen schreiben:

public class HelloWorld {
    public static void main(String[] args) {
        int x = 3;
        System.out.println(++x);
        System.out.println(x);
    }
}

Hier wird 4 und 4 ausgegeben, weil im ersten System.out.println() schon vor der Ausgabe das x auf 4 erhöht wurde.

Ist das x++ bzw. das x– in einer eigenen Zeile, ist es egal, ob man das ++ oder — davor oder danach schreibt.

8. Variablen und Strings in System.out.println() kombinieren

Willst du nur reinen Text oder reine Variablen oder reine Rechnungen mit System.out.println() ausgeben, funktioniert das sehr einfach.

Willst du einen Text mit einer Variable kombinieren, brauchst du ein +, um sie zu kombinieren:

public class HelloWorld {
    public static void main(String[] args) {
        int x = 3;
        int y = 2;
        System.out.println("Ergebnis: " + x);
    }
}

Was allerdings manchmal Probleme schafft, ist die Kombination Text und Rechnung:

public class HelloWorld {
    public static void main(String[] args) {
        int x = 3;
        int y = 2;
        System.out.println("Ergebnis: " + x + y);
    }
}

Hier würde „Ergebnis: 32“ ausgegeben werden, weil Java nicht weiß, ob das 2. +-Symbol als Addition oder als String-Verkettung (Texte zusammenhängen) gemeint ist.

Um das zu vermeiden, verwende zusätzliche Klammern:

public class HelloWorld {
    public static void main(String[] args) {
        int x = 3;
        int y = 2;
        System.out.println("Ergebnis: " + (x + y));
    }
}

Willst du mehr Variablen und/oder Texte zusammenhängen, setze immer dazwischen ein + Zeichen ein:

public class HelloWorld {
    public static void main(String[] args) {
        int x = 3;
        int y = 2;
        System.out.println("Das Ergebnis aus " + x + " und " + y + " ist: " + (x + y));
    }
}

Viel Freude noch mit Variablen in Java 🙂

Diskussion zum Tutorial