Variablen in Java

Eine Variable hat eine Speicheradresse auf einen Speicherort zeigt in der der Inhalt steht, der in der Variable initialisiert wird. Die Größe des Speicherorts entspricht der Größe des angegebenen Datentypes.

Besser kann man es sich so vorstellen. Man steht vor einem Schrank (Arbeitsspeicher)  mit lauter verschieden große Schubläden. Jeder Schubladen hat eine Nummer (Speicheradresse). Wenn wir jetzt etwas darin verstauen wollen, wollen wir natürlich so wenig Platz wie möglich verbrauchen, weil nur ein Gegenstand (Variableninhalt) in eine Schublade darf. Wir suchen sich also die passende Schublade (Größe des Datentyps) aus und legen den Inhalt rein. Natürlich müssen wir uns jetzt die Nummer des Schubladen irgendwie merken, damit wir schnell den richtigen Schubladen wieder finden. Deshalb schreiben wir eine Kurze Notiz (Bezeichner) in der unsere Nummer (Speicheradresse) des Schubladens  steht. Wenn wir jetzt einen Gegenstand suchen Schauen wir unsere Notizen durch und wissen genau in welcher Schublade unser gesuchter Inhalt ist.

Durch dieses Beispiel kann man sich auch viel einfacher vorstellen wie die Typumwandlung geht, die schon im vorherigen Tutorial "Einfache Datentypen in Java" angesprochen wurde. Ein kleiner Inhalt kann in einen grösseren Schubladen ohne Probleme vom Compiler automatisch umgewandelt werden, dies ist die Implizite Datenumwandlung. Wenn aber ein größerer Inhalt in einen kleineren Schubladen soll muss man den Compiler erst angeben, dass man es will und er es einfach sozusagen reinquetschen soll ohne Rücksicht auf Verluste (Rundungsfehler), das ist die Explizite Datenumwandlung.

Jetzt schauen wir uns mal ein Beispiel an:

Wie wir sehen wird hier die Summe von 6 + 8 ausgegeben. Wenn wir jetzt andere Zahlen addieren wollen müssen wir 4 Werte korrigieren (In der Zeichenkette müssen ja auch die passenden Zahlen stehen). Bei großen Programmen kann es dann sehr umfangreich werden wenn man einen Wert ändern möchte. Deshalb deklarieren und initialisieren wir zwei Datentypen. Für den Anfang schaut es nach mehr Arbeit aus, aber dieses bisschen mehr Aufwand ist bei größeren Programmen vorteilhaft und man will auch nicht immer den gleichen Wert berechnen.

Bei diesen Beispiel müssen wir nur noch die beiden Werte initialisieren, also den Datentypen mit den = Operator zuweisen. Damit ist schon einmal der Aufwand zum korrigieren geringer geworden, wie man bestimmt merkt. Jetzt schauen wir uns mal den Code genauer an.

int a, b;

Hier werden die beiden Variablen a und b erzeugt (deklariert), die Bezeichner  haben eine Größe von 4 Byte. Es wird für die beiden Variablen ein Speicherplatz reserviert und jede der beiden Variablen hat eine Speicheradresse für ihren reservierten Speicherplatz.  Mit der angegebenen Speicheradresse zeigt die Variable auf den Speicherplatz. Variablen kann man wie bei dem Beispiel in einer Zeile deklarieren, aber dann nur mit dem Selben Datentyp.

a = 6;

b = 8; 

In den beiden Zeilen werden die Werte 6 und 8 initialisiert (werden die Variablen a und b mit dem Operator = zugewiesen).  

System.out.println( a + " + " + b " = " + (a + b));

Diese Zeile schaut etwas kompliziert aus, als erstes deklariert der Compiler einen String ohne Bezeichner.

Dann wird der Teil a + " + " + b " + " = " in den String initialisiert jetzt schaut es sozusagen so aus:

System.out.println("a + b = " + (a + b);

Jetzt deklariert der Compiler einen int Variable ohne Bezeichner und initialisiert die Summe von a und b.

System.out.println("a + b = " + 14);

Der Compiler fügt dem String die Variable int dem String hinzu und gibt den kompletten String auf der 

Konsole aus.

Achtung: Wenn (a + b) nicht in Klammern steht werden a und b nicht addiert sondern nur dem String hinzugefügt.

Manchmal ist es sinnvoll eine Variable mit einem Wert zu initialisieren der bei dem Programmablauf gleich bleibt. Dafür gibt es die final-Variable (oder symbolische Konstante). Um so eine Konstante zu deklarieren, muss man der üblichen Deklaration mit der Initialisierung das Schlüsselwort final voranstellen.

Unser Programm ist jetzt etwas umgebaut worden, jetzt kann der Umfang eines Kreises berechnet werden. PI ist eine final-Variable, solche Variablen werden nur mit Großbuchstaben geschrieben und die Initialisierung muss in der selben Zeile der Deklaration gemacht werden. Es kann auch kein neuer Wert initialisiert werden, bei einem Versuch einen neuen Wert zu initialisieren, gibt der Compiler eine Fehlermeldung zurück.

Operatoren

Bei den Operatoren gibt es die einstelligen Operatoren (unär bzw. monadisch), die zweistelligen Operatoren (binär bzw. dyadisch) und die dreistelligen Operatoren (ternär bzw. triadisch).

Einstellige Arithmetische Operatoren:

Zweistellige Arithmetische Operatoren:

Der dreistelligen Bedingungsoperator ?: (wird sehr selten benutzt), er ist eigentlich die verkürzte Schreibweise der if-Entscheidungsanweisung. Wir werden sie mit den Entscheidunsanweisungen behandeln.

Die oben aufgeführten Arithmetischen Operatoren können für die Datentypen : byte, short, int, long, float, double oder char verwendet werden. Der Operator + kann auch dazu verwendet werden Zeichenketten zu verbinden (dies haben wir in den vorherigen Tutorials schon verwendet).

Bitoperatoren
Auf diese Operatoren werde ich jetzt nicht eingehen, sie sind auch für Anfänger sehr uninteressant, eventuell werde ich aber diesen Punkt noch ergänzen und doch noch darüber schreiben.

Zuweisungsoperator
Der Zuweisungsoperator = hat eine Sonderstellung. Mit ihm kann man Variablen Werte zuordnen.

x = 7;

Der Variable x wird der Wert 7 zugeordnet. Es kann aber auch eine Variable anstatt eines Konstanten Werts zugeordnet werden.

x = y = z = 9;

Hier wird der konstante Wert 9 z zugeordnet, dann y und danach x zugeordnet.

x = x + 5

Hier wird die Variable x addiert mit dem konstanten Wert 5 und die Summe x zugeordnet.

Es gibt in Java verkürzte Schreibweisen für binäre Operatoren:

Also ist durch die verkürzte Schreibweise:

x += 5; das Selbe wie x = x + 5;

Vergleichsoperatoren und logische Operatoren

Die Vergleichsoberatoren sind immer binär. Es werden zwei Werte (Operanten) miteinander verglichen und gibt ein Ergebnis vom Typ boolean zurück (entweder true oder false).

Vergleichsoperatoren in Java:

Die logischen Operatoren werden oft mit den Vergleichsoperatoren verwendet um komplexere Ausdrücke zu erstellen. Die logischen Operatoren erwarten immer einen Wert vom Typ boolean und gibt auch solchen zurück.

Logisch Und, Oder und die Negation:

Logische Operatoren:

Bei a & b und a | b werden beide Operanten ausgewertet. Bei a && b wird der zweite Operant nur ausgewertet wenn der erste Operant true ist. Bei a || b wird der zweite Operant nur ausgewertet wenn der erste Operant false ist.

Inkrement- und Dekrementoperatoren

Dies Operatoren sind eigentlich auch nur eine verkürzte Schreibweise. Diese beiden Operatoren können aber nur mit Variablen verwendet werden. Wenn man den Wert nur um 1 erhöhen will ist es mit dem Inkrementoperator möglich:

a++;

oder wenn man den Wert um 1 verringern will mit dem Dekrementoperator:

a--;

Es ist möglich den Operator Präfix (vor der Variable) oder Postfix (nach der Variable) zu verwenden. Es gibt bei dem beiden Schreibweisen Präfix und Postfix einen Unterschied bei der Auswertung.

a = 5;

b = ++a;

x = 8;

y = x--;

Die Variable b hat den Wert 6, aber die Variable y hat den Wert 8. Warum ist das so? Ganz einfach, die Variable x wird erst den Wert an die Variable y zuweisen und dann erst wird x um 1 verringert. 

Jetzt sind wir am Ende des dritten Tutorials, es war nicht gerade einfach soviele Informationen zusammenzufassen, es hat aber auch Spaß gemacht.