Kontrollstrukturen
Um die formalen Eigenschaften eines Algorithmus in die syntaktischen Eigenschaften eines Programmes zu überführen, ist es von nöten einzelne Anweisungen eines Algorithmus' miteinander zu verknüpfen.
In vielen Programmiersprachen, so auch im speziellen in Java, gibt es dafür eine kleine Grundmenge an sogenannten Kontrollstrukturen, die den Fluss eine Programmes steuern.
Diese sind im speziellen: Die sequenzielle (hintereinander) Ausführung einzelner Programmanweisungen, das Zusammenfassen von Anweisungssequenzen in Blöcken, das Formulieren von alternativen Programmpfaden, das Formulieren von Fallunterscheidungen und das wiederholte Durchführen von Programmsequenzen.
Inhaltsverzeichnis
Anweisungssequenzen
Zwei Anweisungen werden hintereinander durchgeführt, indem sie mit einem Semikolon ( ; ) getrennt werden. In Java im speziellen ist eine einzelne Anweisung ohne Semikolon unvollständig.
Block
Eine Anweisungssequenz kann im syntaktischen Sinne als eine einzelne Anweisung aufgefasst werden, wenn sie innerhalb eines Blockes stehen. Ein Block wird durch eine öffnende und schließende geschweifte Klammer ( { ... } ) deklariert. Variablen, welche innerhalb eines Blockes deklariert wurden, sind nur innerhalb dieses Blockes sichtbar und überdecken Variablen mit gleichen Namen außerhalb des Blockes. Anwendung finden Blöcke immer dann, wenn eine der weiteren Kontrollflussstrukturen syntaktisch eine einzelne Anweisung erwartet, man jedoch mehr als eine einzelne Anweisung auszuführen gedenkt. Umgangssprachlich kann man sagen, Anweisungen, die in einem Block stehen, gehören zusammen und bilden eine Einheit.
Nicht zu verwechseln sind Blöcke mit den Rümpfen von Klassen-, Methoden- und Konstruktordeklarationen. Diese fassen zwar auch Anweisungssequenzen (im Falle von Methoden und Konstruktoren) oder Deklarationen (im Falle von Klassen) zusammen, sind jedoch fester, syntaktischer Bestandteil der Deklaration.
Beispiele
[...]
int x = 5;
{ /* modify x and print */
x = x + 10;
System.out.println(x);
}
System.out.println(x);
[...]
Das obere Codefragment deklariert eine Variable x und fasst das Erhöhen dieser Variablen und ihre Ausgabe auf der Konsole in einem Block zusammen. In diesem Beispiel hat der Block keinen weiteren Nutzen als dem lesenden Programmierer die beiden Zeilen hervorzuheben. Die Ausgabe des Programmes ist daher zwei mal "15".
[...]
int x = 5;
{ /* shadow x and print */
int x = 10;
System.out.println(x);
}
System.out.println(x);
[...]
In diesem Beispiel wird die Variable x außerhalb des Blockes von der neu deklarierten Variablen innerhalb des Blockes überdeckt. Anders, als wenn man eine Variable innerhalb des gleichen Blockes mehrfach deklariert, ist dies kein Fehler! Wird innerhalb des Blockes auf eine Variable mit dem Namen x zugegriffen, so wird zuerst nach einer Variablen gesucht, die innerhalb des Blockes deklariert wurde. Findet sich keine solche, so wird nach einer Variable außerhalb des Blockes mit diesem Namen gesucht. Da die Variable x innerhalb des Blockes mit dem Wert x deklariert und initialisiert wurde, ist die 1. Ausgabe des Programmfragmentes "10". Die zweite Ausgabe des Programmfragmentes findet außerhalb des Blockes statt, wo die innere Variable des Blockes nicht mehr sichtbar[1] ist. Somit wird auf die Variable x mit dem Wert 5 zugegriffen und die 2. Ausgabe ist "5".
[...]
{ /* shadow x and print */
int x = 10;
System.out.println(x);
}
System.out.println(x);
[...]
Dieses Codefragment würde nicht compilieren, da die Variable x außerhalb des Blockes nicht sichtbar ist. Sie müsste irgendwo außerhalb des Blockes, vor Aufruf der println()-Methode deklariert und initialisiert worden sein.
Alternativen mit if
Fallunterscheidungen mit switch-case
Wiederholung mit Schleifen
Eigener Artikel: while Eigener Artilel: do-while Eigener Artikel: for
Fußnoten
- ↑ Sie ist ab diesem Moment sogar nicht mehr existent; Durch das öffnen eines weiteren Blockes in der gleichen Ebene wird diese Variable nicht wieder sichtbar!
