Index | Kontrollstrukturen: Schleifen - Entscheidungen - Fehlerbehandlung - Verzweigung

Kontrollstrukturen

Schleifen

while()

Die folgenden Codeschnipsel sind alle äquivalent:

int x = 0;
while( x <= 10 ) {
	System.out.println(x);
	x++;
}

int x = 0;
while( x <= 10 ) System.out.println(x++);

Eine while-Schleife wird so lange ausgeführt, wie der Ausdruck true zurückliefert. Der Ausdruck wird zu Beginn der Schleife ausgewertet, d.h. die Schleife muss nicht notwendigerweise ausgeführt werden.

do..while()

int x = 0;
do {
	System.out.println(x);
	x++;
} while( x <= 10 );

do-while-Schleifen laufen im Gegensatz zu while-Schleifen mindestens einmal durch; erst am Ende jeder Schleife wird der Ausdruck ausgewertet.

for()

for( int x = 0; x <= 10; x++ ) {
	System.out.println(x);
}

for-Schleifen beinhalten die drei Bestandteile Initialisation, Laufbedingung und Inkrement einer Schleife direkt im Aufruf.
Die Auswertung erfolgt zu Beginn der Schleife.

Die Parameter sind alle optional; for( ; ; ) entspricht also einer Endlosschleife.

Ausführlich:
while, do-while: http://java.sun.com/docs/books/tutorial/java/nutsandbolts/while.html
for: http://java.sun.com/docs/books/tutorial/java/nutsandbolts/for.html

Entscheidungen

if()

if( x == 0 ) {
	System.out.println("x ist 0");
} else if( x == 1) {
	System.out.println("x ist 1");
} else {
	System.out.println("x ist weder 0 noch 1");
}

Es wird abgefragt, ob x gleich 0 sei. Ist es das, wird der erste Block (nach if()) ausgeführt. Andernfalls (else) wird gefragt, ob x gleich 1 sei. Trifft dieses nun zu, wird der zweite Block ausgeführt.
Trifft beides nicht zu, wird der letzte Block ausgeführt.

Ausführlich: http://java.sun.com/docs/books/tutorial/java/nutsandbolts/if.html

switch/case

switch( x ) {
	case 0  : System.out.println("x ist 0"); break;
	case 1  : System.out.println("x ist 1"); break;
	default : System.out.println("x ist weder 0 noch 1"); break;	
}

Das Ergebnis des Ausdrucks in switch() wird mit jedem aufgeführten case verglichen. Dabei ist darauf zu achten, dass jeder Wert hinter case einmalig zu sein hat. Wertbereiche (z.B. Abfragen auf x größer 1) sind im Gegensatz zu if() nicht möglich; es muss ein eindeutiger Integer-Wert sein.
Jeder Block beginnt beim passenden case und endet beim nächsten break;.
default bezeichnet den "Andernfalls"-Block, der ausgeführt wird, wenn kein passendes case vorhanden ist.

Ausführlich: http://java.sun.com/docs/books/tutorial/java/nutsandbolts/switch.html

Fehlerbehandlung

Die Fehlerbehandlung in Java erfolgt über sogenannte Exceptions (Ausnahmen). Eine Methode kann im Fehlerfalle (z.B. Teilung durch 0, Datei nicht vorhanden usw...) eine Exception "werfen" (throw). Eine Exception hat einen ganz bestimmten Typ (der von der werfenden Methode benannt wird). Exceptions sind wie Objekte; sie haben eigene Methoden und Attribute.
Diese Exception (also jeder Typ für sich) muss nun vom Programm "gefangen" (catch) werden, andernfalls gibt es einen Laufzeitfehler, d.h. das Programm wird abgebrochen und der Name der Exception wird im Idealfall noch ausgegeben.

try..catch..finally

try {
	/* Anweisung(en), die eine Exception werfen könnten  */
} catch (type name) {
	/* Anweisungen, die ausgeführt werden, wenn eine     */
	/* Exception vom Typ type geworfen wurde - z.B.:     */
	System.out.println( name.getMessage() );
} catch (type2 name2) {
	/* Weitere Exceptions von anderen Typen fangen       */
} finally {
	/* Anweisungen, die auf jeden Fall ausgeführt werden */
	/* (zum Aufräumen usw.)                              */
}

Man "versucht" (try), eine Methode, die eine Exception werfen könnte, auszuführen. Dann "fängt" (catch) man die Exception(s) und geht auf den (die) Fehler ein (z.B. Fehlermeldung ausgeben). Die Exception liegt dann als Objekt vor mit eigenen Methoden. Schlussendlich (finally) räumt man auf.

Ausführlich: http://java.sun.com/docs/books/tutorial/java/nutsandbolts/exception.html
Noch ausführlicher: http://java.sun.com/docs/books/tutorial/essential/exceptions/index.html

throw

public void Method() throws Exceptiontype {
	if( ReasonForExceptionIsFulfilled ) 
		throw new Exceptiontype();
}

Hiermit wird eine Exception Exceptiontype geworfen, sofern die Bedingung ReasonForExceptionIsFulfilled true ist.
Der Exceptiontyp muss dafür bereits definiert sein. Sie muss also entweder eine vordefinierte (in den Java-Bibliotheken) sein oder eine selbst definierte. Dies funktioniert praktisch genau wie die Definition einer Klasse.

zum Seitenanfang