JAVA - Kontrollstrukturen

Übungen Informatik I 

JAVA 

- Kontrollstrukturen 

http://www.fbi-lkt.fh-karlsruhe.de/lab/info01/Tutorial 

Helga Gabler, Holger Vogelsang, Christian Pape 

Übungen Informatik 1 Folie 1


Kontrollstrukturen 

In Java gibt es folgende Gruppen von Kontrollstrukturen: 

1. Verzweigungen 

• Einfachverzweigung if, if-else 

• Mehrfachverzweigung switch/case 

• Auswahloperator ? 

2. Schleifen mit 

• while „abweisende Schleife“ 

• do-Schleife „nichtabweisende Schleife“ 

• for-Schleife „Zählschleife“ 

3. Unbedingte Sprünge mit continue, break 





„ if / if-else – Anweisung“ 

Syntax: 

if (Boole'scher Ausdruck ) anweisung ; 

// Wenn Ausdruck wahr ist, führe die Anweisung aus. 

if (Boole'scher Ausdruck ){ // Wenn Ausdruck wahr ist, 

anweisung1; 

// führe anweisung1 aus 

} else { // Wenn Ausdruck falsch ist, 

anweisung2; 

// führe anweisung2 aus 

} 

Bei mehr als einer Anweisung müssen diese mit { } als ein Block 

geklammert werden. 

Verschachtelte if-else-Anweisungen (Klammern wegen Mehrdeutigkeit) 

if (bedingung1) { 

if (bedingung2){ 

anweisung1; 

} else { 

anweisung2; 

} 

} 




Kontrollstrukturen Auswahloperator ? 

int x=2, y=3, z=4; 

if ( x == 2 && y


Code-Konvention 

„Kontrollstrukturen“ 

Einfache Anweisungen 

Nur eine Anweisung pro Zeile. 

argv++; 

argc--; 

argv++; argc--; // Nein! 

Bedingungen 

if (condition) { 

statements; 

} 


statements; 

} else { 

statements; 

} 


statements; 

} else if (condition) { 

statements; 

} else if (condition) { 

statements; 

} 

// Vermeiden (Klammern !!) 

if (condition) 

statement; 




Kontrollstrukturen „ switch – Anweisung“ (Mehrfachverzweigung) 

Syntax: 

switch (Ausdruck ) { 

} 

case konstante1: anweisung1; 

... 

case konstanteN: anweisungN; 

default: anweisung; 

// Wert des Ausdruck bestimmt 

// das Einsprungziel 

Die switch-Anweisung kann die Folge von if-else-Anweisungen ersetzen 

Ausdruck: 

- muss vom Typ byte, short, char oder int sein. 

- steuert die switch-Anweisung 

case: 

Einsprungziel 

default: 

wenn der Wert des Ausdrucks mit keinem case-Fall übereinstimmt 





Beispiel1: 

int a = 1; 

System.out.println (a); 

switch (a) { 

case 0 : System.out.println ("Null"); 

case 1 : System.out.println ("Eins"); 

case 2 : System.out.println ("Zwei"); 

case 3 : System.out.println ("default"); 

} 

Ausgabe des Programms für a = 1: 1 

Eins 

Zwei 

default 

break-Anweisung 





Beispiel2: 

int a = 1; 

System.out.println (a); 

switch (a) { 

case 0 : System.out.println ("Null"); 

break; 

case 1 : System.out.println ("Eins"); 

break; 

case 2 : System.out.println ("Zwei"); 

break; 

case 3 : System.out.println ("default"); 

break; 

} 

Ausgabe des Programms für a = 1: 1 

Eins 





Beispiel 3: 

„ist das Zeichen b ein Sonderzeichen oder Buchstabe?“: 

char b = ‘:‘; 

switch(b) { 

case '0': case '1': case '2': case '3': 

case '4': case '5': case '6': case '7': 

case '8': case '9': 

System.out.println("Ziffer!"); 

break; 

case '.': case ',': case ';': 

case '?': case '!': case ':': 

System.out.println("Satzzeichen!"); 

break; 

default: 

System.out.println("Buchstabe/Sonderzeichen!"); 

} 





„ while – Schleife“ 

• Syntax: 

while( Boole'scher Ausdruck ){ // Solange der Ausdruck wahr ist, 

anweisung; 

// führe die Anweisung aus. 

} 

• Beispiel ohne Block: 

int counter = 0; 

while( counter < 99 ) 

System.out.println( counter++ ); 

• Beispiel ohne Rumpf: 

while( calculate( value ) < 99 ); 

• Beispiel mit Block: 

Bei mehr als einer Anweisung müssen die Anweisungen mit { } als ein Block 

geklammert werden. 

int count = 0; 

while( count < 99 ) { 

++count; 

System.out.println( calculate( count )); 

} 





„ while – Schleife“ 

• Achtung (Position des Semikolons): 

while( count < 10 ); // Semikolon zu viel ! 

{ 

++count; 

// Ist zwar eingerückt, gehört 

} // aber nicht zur Schleife! 

Tipp: Setzen Sie immer den Block in Klammern {}. Dieses erhöht die 

Lesbarkeit und verringert die Fehlerwahrscheinlichkeit. 

• Erst Bedingung testen, dann Anweisung durchführen: 

Bei einer while-Schleife wird erst die Bedingung geprüft und 

wenn sie wahr ist wird die Anweisung /Anweisungsblock 

ausgeführt. 

→ eine while-Schleife braucht nicht unbedingt durchlaufen werden. 

Beispiel: 

int j=0; 

while (j



„ do – Schleife“ 

• Syntax: 

do { 

anweisung; 

} 

while( Boole'sche Laufbedingung ); 

//abhängige Anweisung 

• Unterschied zur while-Schleife: 

Erst Anweisung durchführen, dann Bedingung testen. 

→ die Schleife wird mindestens 1x durchlaufen 

→ nichtabweisende Schleife 

• Beachte: Position des Semikolons → hinter while! 






• Beispiel 1: 


do { 

calculate( ++counter ); 

} 

while( counter < 99 ); 

oder kurz: 


do ; while( calculate( ++counter ) < 99 ); 

• Beispiel 2: 

int i=0; 

do { 

System.out.print(i++ + " "); 

} while ( i




Beispiel 3: 

public class BeispielDoWhile { 

public static void main (String[] args) { 

int i = 0; 

do { 

System.out.println(“do while i


Kontrollstrukturen „Inkrement/Dekrement – Operator“ 

Inkrement- und Dekrement-Operatoren gibt es als 

- Postfix-Operator (i++ / i--) 

Operation wird angewandt, nachdem der Wert des Ausdruck 

zurückgegeben wird 

- Präfix –Operator (++i / --i) 

Operation wird angewandt, bevor der Wert des Ausdruck 

zurückgegeben wird 

Beispiel: 

public class InkDekOp { 

public static void main(String[] args) { 

int i = 4711; 

} 

} 

System.out.println (i++ + " " + ++i + " " + i ); 

System.out.println (i-- + " " + --i + " " + i ); 





„ For – Schleife“ 

• Syntax: 

for( Initialisierungen; Grenzbedingung; Zählen ) { 

abhaengige_anweisung 

} 

• Beispiel: 

Initialisierung Grenzbedingung Zählen 

• Initialisierung 

for( int i = 0; i < max; i++ ) { 

System.out.println( i ); 

} 

• initialisieren des Schleifenzählers, die Zählvariable muss ganzzahlig sein 

• wird beim Eintritt in die Schleife einmal ausgeführt. 

• darf aus mehreren Ausdrücken bestehen, die durch Komma getrennt sind. 

• Grenzbedingung: 

• wird vor jedem Durchlaufen der for-Schleife getestet 

• wenn wahr anweisungen ausführen schrittweite berechnen 

• wenn falsch weiter nach der geschweiften Klammer der for-Schleife 

• for-Schleife wird sooft durchlaufen, wie die Grenzbedingung true ist 

• Zählen 

• dieser Ausdruck wird nach jedem Durchlaufen der Schleife ausgeführt 

( Schleifenvariablen aktualisieren) 

• darf aus mehreren Ausdrücken bestehen, die durch Komma getrennt sind. 






• Beispiel (Übergang von while- zu for-Schleife): 

int count = 0; 

// Initialisierung 

while( count < 10 ) { 

// Laufbedingung 

System.out.println( “ No:" + count ); 

count++; // Weiterzaehlen 

} 

Als for-Schleife: 

for( int count = 0; count < 10; count++ ) { 

System.out.print( “ No:" + count ); 

} 

• Beispiele: 

public static void main (String[] args) { 

} 

int i; 

System.out.println (); 

for (i=1; i




Weitere Beispiele: 

for( int count = 0; count < 10; System.out.print( count++ )); 

Jeder der drei Teile kann weggelassen werden! 

for( ; count < 10; System.out.print( count++ )); // äqivalent zu 

// while(laufbedingung) 

for( ; ; System.out.print( count++) ); 

// äquivalent zu while(true) 

• Mehr als drei Schleifen sollten nicht geschachtelt werden. ( Methoden einbauen.) 

• übliche Bezeichner für Schleifenvariablen: i,j,k vom Typ int. 






for (init; condition; updt) { 

statements; 

} 

do { 

statements; 

} while (condition); 

while (condition) { 

statements; 

} 

„Kontrollstrukturen“ 

switch (condition) { 

case ABC: 

statements; 

/* falls through */ 

case DEF: 

statements; 

break; 

case XYZ: 

statements; 

break; 

while (condition) 

statements; 

} 

default: 

statements; 

break; 





public void run (int[] values) { 

int hold; 

} 

for( int pass = 1; pass < values.length; pass++ ) { 

for( int i = 0 ; i < values.length - 1; i++ ) { 

if( values[ i ] > values[ i + 1 ] ) { 

hold = values[ i ]; 

values[ i ] = values[ i + 1 ]; 

values[ i + 1 ] = hold; 

} 

} 

} 





Verteilung von Leerzeichen 

Leerzeichen sollten in den folgenden Situationen verwendet werden: 

• Ein Schlüsselwort, gefolgt von einer Klammer, Beispiel: 

while (true) 

• Nach einem Komma in einer Argumentenliste. 

f (int a, int b) 

• Vor und nach einem binären Operator außer ., Beispiel: 

int i = a + b; 

• Zum Trennen von Ausdrücke in einer for-Schleife, Beispiel: 

for (int i = 0; i < 10; i++) 

• Nach einem cast-Operator, Beispiel: 

int i = (int) x; 

Leerzeichen sollten nicht verwendet werden: 

• Zum Trennen von unären Operatoren von ihren Argumenten, 

Beispiel: 

int i = j++; 





„break und continue“ 

„Unbedingte Sprünge break, continue“ 

• Bieten zwei Möglichkeiten, normale Auswertungsreihenfolgen 

einer Schleife zu verändern 

• Gibt es jeweils mit und ohne Marken (Label) 

break-Anweisung innerhalb einer Schleife: 

Schleife wird verlassen und das Programm mit der ersten Anweisung 

nach der Schleife fortgesetzt. 

continue-Anweisung innerhalb einer Schleife: 

das Programm springt an das Ende des Schleifenrumpfs 

und beginnt mit der nächsten Iteration 





„unlabeled break“ 

unlabeled break: 

break-Anweisung ohne Marken 

- beendet aktuelle Schleife 

- setzt Programmausführung hinter der Schleife fort 

(man kann grundsätzlich die innerste for-,while-,do- oder 

switch-Anweisung verlassen) 

public class Break01 { 

public static void main(String[] args) { 

for(int i = 1; i < 1000000; i++) { 

System.out.println(i); 

if (i > 5) 

break; 

} 

} 

} 





„unlabled continue“ 

continue-Anweisung: 

• beendet aktuelle Schleife nicht, 

• springt an das Ende der umgebenden Schleife. 

• Schleifenbedingung wird überprüft, und 

die Schleife läuft evtl. weiter. 

int zahl = 12; 

while (zahl > 0) { 

zahl--; 

if( zahl % 3 == 0) continue; 

System.out.println("zahl = " + zahl); 

} 

( druckt nur, wenn nicht durch 3 teilbar.) 





„labeled break“ 

break Label; 

- mit einem unlabeled break kann man nur die innerste Schleife verlassen 

- mit einem labeled break (label = Marke) kann man zwei oder mehr 

ineinandergeschachtelte Schleifen beenden. 

- Ein Label besteht aus Bezeichner + Doppelpunkt (TestSchleife:) 

TestSchleife: 

// Label = Name für die folgende Schleife 

for(int i = 1; i < 1000000; i++) { 

for(int j = 1; j < 1000000; j++) { 

System.out.println(i + j); 

if (j > 5) 

break TestSchleife; // springt hinter die Schleife „TestSchleife“ 

} 

} // Ende for i = Ende TestSchleife 





„labeled break“ 

TestSchleife: 

for (int i = 1; i < 3; i++) { 

// Name für äußere Schleife 

NochEinLabel: 

// Name für innere Schleife 

for (int j = 1; j < 10; j++) { 

System.out.println(i + j); 

if (j > 2) { 

break NochEinLabel; // Ende der inneren Schleife 

} // Das Programm wird nach 

// dieser Zeile fortgesetzt. 

System.out.println(“i=“ + i + “ j=“ + j); 

}

JAVA - Kontrollstrukturen

Sie wollen auch ein ePaper? Erhöhen Sie die Reichweite Ihrer Titel.

Template löschen?

Als Template speichern?