|
» Initialisierung
|
nach oben «
|
Im folgenden schließt sich gewöhnlich die Initialisierung, sprich Wertezuweisung an. Hierbei werden den
Variablen Daten zugewiesen. Ansonsten sind alle Variablen mit einem Standardwert vorbelegt. Dieser hängt wiederum
vom Datentyp ab und kann aus dem vorhergehenden Kapitel ermittelt werden.
Die Initialisierung erfolgt durch den Zuweisungsoperator in Form eines Gleichheitszeichens. Es sei allerdings darauf
hingewiesen, dass man nur zum Datentyp passende Werte verwendet, da man sonst Fehler erhält.
|
Name = Wert;
|
Das folgende Beispiel deklariert eine Intergervariable und initialisiert sie in der nächsten Anweisung mit
einem Wert.
|
public class MyClass
{
public static void main(String[] args)
{
int i;
i = 2;
}
}
|
Interessanterweise lassen sich die Schritte der Deklaration und Initialisierung in einer einzigen Anweisung
zusammenfassen.
|
Typ Name = Wert;
|
Ein praktisches Beispiel für die kombinierten Anweisungen.
|
public class MyClass
{
public static void main(String[] args)
{
int i = 2;
}
}
|
|
» statische Variablen
|
nach oben «
|
Statische Variablen sind im Gegensatz zu anderen Variablen einer Klasse nicht an eine von ihr gebildeten Instanz
gebunden. Das heißt, dass statische Variablen immer zur Klassendefinition selbst gehören und nicht mit
einer neuen Instanz erstellt werden. Statische Variablen gelten also für alle Instanzen einer Klassendefinition.
Bei der Deklaration wird das Static - Schlüsselwort verwendet, welches die Variable als statisch markiert.
|
static Typ Name;
|
Ein praktisches Beispiel für die Deklaration einer statischen Variable. Beachten Sie die Voranstellung des
Static - Schlüsselwortes vor den eigentlichen Typ. Das Public - Schlüsselwort muss uns an dieser Stelle
noch nicht interessieren.
|
class Test
{
static public int i = 2;
}
|
Da aber statische Variablen nun nicht mehr zu einer einzelnen Instanz zählen, sondern zur Klasse, werden sie
auch nur ein einziges mal erzeugt. Auch der Zugriff unterscheidet sich. Eine solche Variable kann nur über den
Klassennamen erreicht werden. Dazu wird der Variablenname nach der direkten Klasse durch einen Punkt getrennt. Des
weiteren befindet sich unsere Testvariable in einer externen Klasse innerhalb derselben Datei.
|
class Test
{
static public int i = 2;
}
public class MyClass
{
public static void main(String[] args)
{
System.out.print(Test.i);
}
}
|
2
|
Die Merkmale von konstanten und statischen Variablen lassen sich auch vereinen. Dazu müssen lediglich beide
Schlüsselwörter verwendet werden. Die Initialisierung ist in diesem Fall dann wieder unabdingbar.
|
final static Typ Name;
|
Zu Demonstrationszwecken bedienen wir uns der vorhergehenden Beispiele. Wir haben lediglich die beiden Schlüsselwörter
Final und Static vereint, und somit auch ihre Besonderheiten in Form einer expliziten Initialisierung und der Aufrufregeln.
|
class Test
{
final static public int i = 2;
}
public class MyClass
{
public static void main(String[] args)
{
System.out.print(Test.i);
}
}
|
2
|
|
» Gültigkeitsbereich
|
nach oben «
|
Alle erzeugten Variablen unterliegen einem sogenannten Gültigkeitsbereich. Dieser bestimmt, in Abhängigkeit
des Ortes der Variablendeklaration, deren Sichtbarkeit und Lebensdauer.
Mit Ausnahme der statischen Variablen, sind alle anderen immer auf ihren Block beschränkt. Endet ein Block in Form
eines Funktionsrumpfes, zweier Blockklammern oder einer Klassendefinition, so endet auch die Speicherberechtigung einer
Variable innerhalb dieses Blocks.
Eine einmal deklarierte Variable ist nur in ihrem und weiteren Unterblöcken sichtbar. Wird der Block verlassen, so
wird die Variable ebenfalls gelöscht.
Unser nächstes Beispiel definiert eine Zeichenvariable. Danach bilden wir einen neuen Block in Form einer Bedingung.
Innerhalb dieses Blocks wird eine neue Variable deklariert. Dort könenn wir noch auf die untergeordnete lokale Variable
zugreifen. Auf die neue Variable hingegen nicht mehr, da mit Verlassen des Blocks auch diese Variable gelöscht wird.
|
public class MyClass
{
public static void main(String[] args)
{
int i = 2;
if(true)
{
char c = '!';
System.out.println(i);
System.out.println(c);
}
System.out.println(i);
//System.out.println(c); // nicht mehr sichtbar
}
}
|
2
!
2
|
Wie bereits erwähnt, so liegt der Unterschied bei den statischen Variablen. Sie haben im Rahmen ihrer Klasse einen
globalen Gültigkeitsbereich und stehen allen Teilen des Programms zur freien Verfügung. Sie terminieren erst
bei Programmende aus dem Speicher.
|
|
» Inkrementierung und Dekrementierung
|
nach oben «
|
An dieser Stelle möchten wir einen kleinen Auszug aus dem Kapitel der Operatoren einschieben. Oft kommt es in der
angewandten Programmierung zu dem Fall, dass eine Variable um jeweils nur einen Zählerstand erhöht oder erniedrigt
wird. Aus diesem Grund stehen zwei Operatoren zur Verfügung, die auf schnelle Weise exakt diese Anforderung realisieren.
Beide Operatoren bestehen entweder aus einem doppelten Plus- oder Minuszeichen. Das Pluszeichen inkrementiert und das
Minuszeichen dekrementiert eine Variable.
|
++Variable;
Variable++;
--Variable;
Variable--;
|
Das folgende Beispiel wird die zwei Variablen jeweils um einen Stellenwert erhöhen, beziehungsweise erniedrigen.
|
public class MyClass
{
public static void main(String[] args)
{
int i = 2;
int d = 2;
System.out.println(++i);
System.out.println(--d);
}
}
|
3
1
|
In unserem Beispiel haben wir die Operatoren den Variablen vorangestellt. Nun gibt es auch einen Fall, in dem wir die
Operatoren den Variablen nachstellen können, wobei die Begriffe des Präfix und Postfix ins Spiel kommen.
|
» Präfix
Bei Operationen mit einem Präfix wird als erstes die Variable hoch- beziehungsweise heruntergezählt und dann
eine etwaige weitere Operation in Form einer Zuweisung durchgeführt.
» Postfix
Bei Operationen mit einem Postfix werden als erstes alle weiteren Operationen durchgeführt. Erst danach wird dann
die entsprechende Variable hoch- beziehunghsweise heruntergezählt.
So simpel sich das System auch anhören mag, so entscheident kann es auch den Programmfluß beeinflussen. Das folgende
Beispiel soll dieses Vorgehen verdeutlichen. Man bedenke jedoch, dass sich die vorliegende Technik nur dann auswirkt, wenn
sich mehrere Operationen in einer Anweisung befinden.
Folglich werden wir ein Beispiel einführen, welchen die unterschiedlichen Ergebnisse der Inkrementierung beziehungsweise
Dekrementierung in einer multiplen Anweisung darstellt.
|
public class MyClass
{
public static void main(String[] args)
{
int a = 2;
int b = 2;
System.out.println(++a);
System.out.println(a++);
System.out.println(a );
System.out.println(--b);
System.out.println(b--);
System.out.println(b );
}
}
|
3
3
4
1
1
0
|
