Galileo Computing < openbook > Galileo Computing - Professionelle Bücher. Auch für Einsteiger.
Professionelle Bücher. Auch für Einsteiger.

Inhaltsverzeichnis
Vorwort
1 Java ist auch eine Sprache
2 Sprachbeschreibung
3 Klassen und Objekte
4 Der Umgang mit Zeichenketten
5 Mathematisches
6 Eigene Klassen schreiben
7 Angewandte Objektorientierung
8 Exceptions
9 Generics, innere Klassen
10 Die Klassenbibliothek
11 Threads und nebenläufige Programmierung
12 Datenstrukturen und Algorithmen
13 Raum und Zeit
14 Dateien und Datenströme
15 Die eXtensible Markup Language (XML)
16 Grafische Oberflächen mit Swing
17 Grafikprogrammierung
18 Netzwerkprogrammierung
19 Verteilte Programmierung mit RMI und Web–Services
20 JavaServer Pages und Servlets
21 Applets
22 Midlets und die Java ME
23 Datenbankmanagement mit JDBC
24 Reflection und Annotationen
25 Logging und Monitoring
26 Sicherheitskonzepte
27 Java Native Interface (JNI)
28 Dienstprogramme für die Java-Umgebung
Stichwort

Download:
- ZIP, ca. 14,1 MB
Buch bestellen
Ihre Meinung?

Spacer
<< zurück
Java ist auch eine Insel (8. Auflage) von Christian Ullenboom
Programmieren mit der Java Standard Edition Version 6
Buch: Java ist auch eine Insel (8. Auflage)

Java ist auch eine Insel (8. Aufl.)
8., aktual. Auflage, geb., mit DVD
1.475 S., 49,90 Euro
Galileo Computing
ISBN 978-3-8362-1371-4
Pfeil 2 Sprachbeschreibung
Pfeil 2.1 Elemente der Programmiersprache Java
Pfeil 2.1.1 Token
Pfeil 2.1.2 Textkodierung durch Unicode-Zeichen
Pfeil 2.1.3 Literale
Pfeil 2.1.4 Bezeichner
Pfeil 2.1.5 Reservierte Schlüsselwörter
Pfeil 2.1.6 Kommentare
Pfeil 2.1.7 Die API-Dokumentation
Pfeil 2.2 Anweisungen formen Programme
Pfeil 2.2.1 Anweisungen
Pfeil 2.2.2 Eine Klasse bildet den Rahmen
Pfeil 2.2.3 Die Reise beginnt am main()
Pfeil 2.2.4 Funktionsaufrufe als Anweisungen
Pfeil 2.2.5 print(), println() und printf() für Bildschirmausgaben
Pfeil 2.2.6 Ausdrucksanweisung
Pfeil 2.2.7 Erste Idee der Objektorientierung
Pfeil 2.2.8 Modifizierer
Pfeil 2.2.9 Anweisungen und Blöcke
Pfeil 2.3 Datentypen, Typisierung, Variablen und Zuweisungen
Pfeil 2.3.1 Primitive Datentypen im Überblick
Pfeil 2.3.2 Variablendeklarationen
Pfeil 2.3.3 Zuweisungsoperator
Pfeil 2.3.4 Variablendeklaration mit Wertinitialisierung
Pfeil 2.3.5 Wahrheitswerte
Pfeil 2.3.6 Ganzzahlige Datentypen
Pfeil 2.3.7 Die Fließkommazahlen float und double
Pfeil 2.3.8 Alphanumerische Zeichen
Pfeil 2.3.9 Gute Namen, schlechte Namen
Pfeil 2.4 Blöcke, Initialisierung und Sichtbarkeit
Pfeil 2.4.1 Blöcke und Anweisungen
Pfeil 2.4.2 Initialisierung von lokalen Variablen
Pfeil 2.4.3 Sichtbarkeit und Gültigkeitsbereich
Pfeil 2.5 Ausdrücke, Operanden und Operatoren
Pfeil 2.5.1 Arithmetische Operatoren
Pfeil 2.5.2 Unäres Minus und Plus
Pfeil 2.5.3 Zuweisung mit Operation
Pfeil 2.5.4 Präfix- oder Postfix-Inkrement und -Dekrement
Pfeil 2.5.5 Die relationalen Operatoren und die Gleichheitsoperatoren
Pfeil 2.5.6 Logische Operatoren Und, Oder, Xor, Nicht
Pfeil 2.5.7 Rang der Operatoren in der Auswertungsreihenfolge
Pfeil 2.5.8 Die Typanpassung (das Casting)
Pfeil 2.5.9 Überladenes Plus für Strings
Pfeil 2.6 Bedingte Anweisungen oder Fallunterscheidungen
Pfeil 2.6.1 Die if-Anweisung
Pfeil 2.6.2 Die Alternative mit einer if/else-Anweisung wählen
Pfeil 2.6.3 Die switch-Anweisung bietet die Alternative
Pfeil 2.7 Schleifen
Pfeil 2.7.1 Die while-Schleife
Pfeil 2.7.2 Die do-while-Schleife
Pfeil 2.7.3 Die for-Schleife
Pfeil 2.7.4 Schleifenbedingungen und Vergleiche mit ==
Pfeil 2.7.5 Ausbruch planen mit break und Wiedereinstieg mit continue
Pfeil 2.7.6 break und continue mit Sprungmarken
Pfeil 2.8 Methoden einer Klasse
Pfeil 2.8.1 Bestandteil einer Funktion
Pfeil 2.8.2 Signatur-Beschreibung in der Java-API
Pfeil 2.8.3 Aufruf einer Methode
Pfeil 2.8.4 Methoden ohne Parameter deklarieren
Pfeil 2.8.5 Statische Methoden (Klassenmethoden)
Pfeil 2.8.6 Parameter, Argument und Wertübergabe
Pfeil 2.8.7 Methoden vorzeitig mit return beenden
Pfeil 2.8.8 Nicht erreichbarer Quellcode bei Funktionen
Pfeil 2.8.9 Rückgabewerte
Pfeil 2.8.10 Methoden überladen
Pfeil 2.8.11 Vorgegebener Wert für nicht aufgeführte Argumente
Pfeil 2.8.12 Finale lokale Variablen
Pfeil 2.8.13 Rekursive Methoden
Pfeil 2.9 Weitere Operatoren
Pfeil 2.9.1 Bits und Bytes
Pfeil 2.9.2 Operationen auf Bit-Ebene
Pfeil 2.9.3 Die Verschiebeoperatoren
Pfeil 2.9.4 Ein Bit setzen, löschen, umdrehen und testen
Pfeil 2.9.5 Bit-Funktionen der Integer- und Long-Klasse
Pfeil 2.9.6 Der Bedingungsoperator
Pfeil 2.9.7 Operator vermisst
Pfeil 2.10 Einfache Benutzereingaben
Pfeil 2.11 Zum Weiterlesen


Galileo Computing - Zum Seitenanfang

2.7 Schleifen Zur nächsten ÜberschriftZur vorigen Überschrift

Schleifen dienen dazu, bestimmte Anweisungen immer wieder abzuarbeiten. Zu einer Schleife gehören die Schleifenbedingung und der Rumpf. Die Schleifenbedingung, ein boolescher Ausdruck, entscheidet darüber, unter welcher Bedingung die Wiederholung ausgeführt wird. In Abhängigkeit von der Schleifenbedingung kann der Rumpf mehrmals ausgeführt werden. Dazu wird bei jedem Schleifendurchgang die Schleifenbedingung geprüft. Das Ergebnis entscheidet, ob der Rumpf ein weiteres Mal durchlaufen (true) oder die Schleife beendet wird (false). Java bietet vier Typen von Schleifen:

  • while-Schleife
  • do-while-Schleife
  • einfache for-Schleife
  • erweiterte for-Schleife
  • Die ersten drei Schleifentypen erklären die folgenden Abschnitte, während die erweiterte for-Schleife nur bei Sammlungen nötig ist und daher später bei Feldern (Kapitel 3) und dynamischen Datenstrukturen (Kapitel 12) Erwähnung findet.

Galileo Computing - Zum Seitenanfang

2.7.1 Die while-Schleife Zur nächsten ÜberschriftZur vorigen Überschrift

Die while-Schleife ist eine abweisende Schleife, die vor jedem Schleifeneintritt die Schleifenbedingung prüft. Ist die Bedingung wahr, führt sie den Rumpf aus, andernfalls beendet sie die Schleife. Wie bei if muss auch bei den Schleifen der Typ der Bedingungen boolean sein.


Beispiel Zähle von 100 bis 40 in 10er-Schritten herunter:

Listing 2.12 WhileLoop.java, main()

int cnt = 100; 
while ( cnt >= 40 ) 
{ 
  System.out.printf( "Ich erblickte das Licht der Welt in Form einer %d-Watt-
                      Glühbirne.%n", cnt ); 
  cnt -= 10; 
}

Vor jedem Schleifendurchgang wird der Ausdruck neu ausgewertet, und ist das Ergebnis true, so wird der Rumpf ausgeführt. Die Schleife ist beendet, wenn das Ergebnis false ist. Ist die Bedingung schon vor dem ersten Eintritt in den Rumpf nicht wahr, so wird der Rumpf erst gar nicht durchlaufen. Der Typ der Bedingung muss boolean sein. [Damit sehen Bedingungen in Java im Gegensatz zu C(++) etwas präziser aus: Statt einfach nur while ( i ) wie in C(++) heißt es in Java: while ( i != 0 ).]


Hinweis Wird innerhalb des Schleifenkopfs schon alles Interessante erledigt, so muss trotzdem eine Anweisung folgen. Dies ist der passende Einsatz für die leere Anweisung.

Listing 2.13 WhileExit.java, main()

while ( ! new Scanner(System.in).next().equalsIgnoreCase("quit") ) 
  ;                              // Rumpf ist leer

Nur wenn auf der Kommandozeile »quit« eingegeben wird, läutet dies das Ende der Schleife ein; andernfalls gibt es eine neue Eingabeaufforderung.


Endlosschleifen

Ist die Bedingung einer while-Schleife immer wahr, dann handelt es sich um eine Endlosschleife. Die Konsequenz ist, dass die Schleife endlos wiederholt wird:

while ( true ) 
{ 
  // immer wieder und immer wieder 
}

Eclipse-Icon In Eclipse lassen sich Programme von außen beenden. Dazu bietet die Ansicht Console eine rote Schaltfläche in Form eines Quadrats, die nach der Aktivierung im Fall eines laufenden Programms die JVM mit den laufenden Programmen beendet.

Endlosschleifen bedeuten normalerweise das Aus für jedes Programm. Doch es gibt Hilfe! Aus dieser Endlosschleife können wir mittels break entkommen. Genau genommen beenden aber auch nicht aufgefangene Exceptions oder auch System.exit() die Programme.


Galileo Computing - Zum Seitenanfang

2.7.2 Die do-while-Schleife Zur nächsten ÜberschriftZur vorigen Überschrift

Dieser Schleifentyp ist eine annehmende Schleife, da do-while die Schleifenbedingung erst nach jedem Schleifendurchgang prüft. Bevor es zum ersten Test kommt, ist der Rumpf also schon einmal durchlaufen worden:


Beispiel Graf Zahl zählt mit do-while von 1 bis 10.

Listing 2.14 DoWhileLoop.java, main()

int pos = 1; 
do 
{ 
  System.out.println( pos ); 
  pos++; 
} while ( pos <= 10 );                // Bemerke das Semikolon

Es ist wichtig, auf das Semikolon hinter der while-Anweisung zu achten. Liefert die Bedingung ein true, so wird der Rumpf erneut ausgeführt. [Das ist in Pascal anders! Hier läuft eine repeat/until-Schleife so lange, bis die Bedingung erfüllt ist, und bricht dann ab.] Andernfalls wird die Schleife beendet, und das Programm wird mit der nächsten Anweisung nach der Schleife fortgesetzt.

Äquivalenz einer while- und einer do-while-Schleife

Die do-Schleife wird seltener gebraucht als die while-Schleife. Dennoch lassen sich beide ineinander überführen. Zunächst der erste Fall: Wir ersetzen eine while-Schleife durch eine do-while-Schleife:

while ( Ausdruck ) 
  Anweisung

Führen wir uns noch einmal vor Augen, was hier passiert. In Abhängigkeit vom Ausdruck wird der Rumpf ausgeführt. Da zunächst ein Test kommt, wäre die do-while-Schleife schon eine Blockausführung weiter. So fragen wir in einem ersten Schritt mit einer if-Anweisung ab, ob die Bedingung wahr ist oder nicht. Wenn ja, dann lassen wir den Programmcode in einer do-while-Schleife abarbeiten.

Die äquivalente do-while-Schleife sieht also wie folgt aus:

if ( Ausdruck ) 
  do 
    Anweisung 
  while ( Ausdruck ) ;

Nun der zweite Fall: Wir ersetzen die do-while-Schleife durch eine while-Schleife:

do 
  Anweisung 
while ( Ausdruck ) ;

Da zunächst die Anweisungen ausgeführt werden und anschließend der Test, schreiben wir für die while-Variante die Ausdrücke einfach vor den Test. So ist sichergestellt, dass diese zumindest einmal abgearbeitet werden.

Anweisung 
while ( Ausdruck ) 
  Anweisung

Galileo Computing - Zum Seitenanfang

2.7.3 Die for-Schleife Zur nächsten ÜberschriftZur vorigen Überschrift

Die for-Schleife ist eine spezielle Variante einer while-Schleife und wird typischerweise zum Zählen benutzt. Genauso wie while-Schleifen sind for-Schleifen abweisend, der Rumpf wird also erst dann ausgeführt, wenn die Bedingung wahr ist.


Beispiel Gib die Zahlen von 1 bis 10 auf dem Bildschirm aus.

Listing 2.15 ForLoop.java, main()

for ( int i = 1; i <= 10; i++ )            // i ist Schleifenzähler 
  System.out.println( i );

Eine genauere Betrachtung der Schleife zeigt die unterschiedlichen Segmente:

  • Initialisierung der Schleife. Der erste Teil der for-Schleife ist ein Ausdruck wie i = 1, der vor der Durchführung der Schleife genau einmal ausgeführt wird. Dann wird das Ergebnis verworfen. Tritt in der Auswertung ein Fehler auf, so wird die Abarbeitung unterbrochen, und die Schleife kann nicht vollständig ausgeführt werden. Der erste Teil kann lokale Variablen deklarieren und initialisieren. Diese Zählvariable ist dann außerhalb des Blocks nicht mehr gültig. [Im Gegensatz zu C++ ist das Verhalten klar definiert, und es gibt kein Hin und Her. In C++ implementierten Compilerbauer die Variante einmal so, dass die Variable nur im Block gilt, andere interpretierten die Sprachspezifikation so, dass diese auch außerhalb gültig blieb. Die aktuelle C++-Definition schreibt nun vor, dass die Variable außerhalb des Blocks nicht mehr gültig ist. Da es jedoch noch alten Programmcode gibt, haben viele Compilerbauer eine Option eingebaut, mit der das Verhalten der lokalen Variablen bestimmt werden kann.] Es darf noch keine lokale Variable mit dem gleichen Namen geben.
  • Schleifentest/Schleifenbedingung. Der mittlere Teil, wie i <= 10, wird vor dem Durchlaufen des Schleifenrumpfs – also vor jedem Schleifeneintritt – getestet. Ergibt der Ausdruck false, wird die Schleife nicht durchlaufen und beendet. Das Ergebnis muss, wie bei einer while-Schleife, vom Typ boolean sein. Ist kein Test angegeben, so ist das Ergebnis automatisch true.
  • Schleifen-Inkrement durch einen Fortschaltausdruck. Der letzte Teil, wie i++, wird immer am Ende jedes Schleifendurchlaufs, aber noch vor dem nächsten Schleifeneintritt ausgeführt. Das Ergebnis wird nicht weiter verwendet. Ergibt die Bedingung des Tests true, dann befindet sich beim nächsten Betreten des Rumpfs der veränderte Wert im Rumpf.

Betrachten wir das Beispiel, so ist die Auswertungsreihenfolge folgender Art:

1. Initialisiere i mit 1.
2. Teste, ob i <= 10 gilt.
3. Ergibt sich true, dann führe den Block aus, sonst ist es das Ende der Schleife.
4. Erhöhe i um 1.
5. Gehe zu Schritt 2.

Schleifenzähler

Wird die for-Schleife zum Durchlaufen einer Variablen genutzt, so heißt der Schleifenzähler entweder Zählvariable oder Laufvariable.

Wichtig sind die Initialisierung und die korrekte Abfrage am Ende. Schnell läuft die Schleife einmal zu oft durch und führt so zu falschen Ergebnissen. Die Fehler bei der Abfrage werden auch »off-by-one error« genannt, wenn zum Beispiel statt <= der Operator < steht. Dann nämlich läuft die Schleife nur bis 9. Ein anderer Name für den Schleifenfehler lautet »fencepost error«. Es geht um die Frage, wie viele Pfähle nötig sind, um 100 m einzuzäunen, sodass alle Pfähle einen Abstand von 10 m haben: 9, 10, 11?

Wann for und wann while?

Da sich die while- und for-Schleife sehr ähnlich sind, besteht die berechtigte Frage, wann die eine und wann die andere zu nutzen ist. Leider verführt die kompakte for-Schleife sehr schnell zu einer Überladung. Manche Programmierer packen gerne alles in den Schleifenkopf hinein, und der Rumpf besteht nur aus einer leeren Anweisung. Dies ist ein schlechter Stil und muss vermieden werden.

for-Schleifen sollten immer dann benutzt werden, wenn eine Variable um eine konstante Größe erhöht wird. Tritt in der Schleife keine Schleifenvariable auf, die inkrementiert oder dekrementiert wird, sollte eine while-Schleife genutzt werden. Eine do-while-Schleife sollte dann ihren Einsatz finden, wenn die Abbruchbedingung erst am Ende eines Schleifendurchlaufs ausgewertet werden kann. Auch sollte die for-Schleife dort eingesetzt werden, wo sich alle drei Ausdrücke im Schleifenkopf auf dieselbe Variable beziehen. Vermieden werden sollten unzusammenhängende Ausdrücke im Schleifenkopf. Der schreibende Zugriff auf die Schleifenvariable im Rumpf ist eine schlechte Idee, wenn sie auch gleichzeitig im Kopf modifiziert wird – das ist schwer zu durchschauen und kann leicht zu Endlosschleifen führen.

Eine Endlosschleife mit for

Da alle drei Ausdrücke im Kopf der Schleife optional sind, können sie weggelassen werden, und es ergibt sich eine Endlosschleife. Diese Schreibweise ist somit semantisch äquivalent mit while(true):

for ( ; ; ) 
  ;

Die trennenden Semikolons dürfen nicht verschwinden. Falls demnach keine Schleifenbedingung angegeben ist, ist der Ausdruck immer wahr. Es folgt keine Initialisierung und keine Auswertung des Fortschaltausdrucks.

Geschachtelte Schleifen

Schleifen, und das gilt insbesondere für for-Schleifen, können geschachtelt werden. Syntaktisch ist das auch logisch, da sich innerhalb des Schleifenrumpfs beliebige Anweisungen aufhalten dürfen. Um fünf Zeilen von Sternchen auszugeben, wobei in jeder Zeile immer ein Stern mehr erscheinen soll, schreiben wir:

for ( int i = 1; i <= 5; i++ ) 
{ 
  for ( int j = 1; j <= i; j++ ) 
    System.out.print( "*" ); 
  System.out.println(); 
}

Als besonderes Element ist die Abhängigkeit des Schleifenzählers j von i zu werten. Es folgt die Ausgabe:

* 
** 
*** 
**** 
*****

Die übergeordnete Schleife nennt sich äußere Schleife, die untergeordnete innere Schleife. In unserem Beispiel wird die äußere Schleife die Zeilen zählen und die innere die Sternchen in eine Zeile ausgeben, also für die Spalte verantwortlich sein.

Da Schleifen beliebig tief geschachtelt werden können, muss besonderes Augenmerk auf die Laufzeit gelegt werden. Die inneren Schleifen werden immer so oft ausgeführt, wie die äußere Schleife durchlaufen wird.

for-Schleifen und ihr Komma-Operator

Im ersten und letzten Teil einer for-Schleife lässt sich ein Komma einsetzen. Damit lassen sich entweder mehrere Variablen gleichen Typs deklarieren – wie wir es schon kennen – oder mehrere Ausdrücke nebeneinander schreiben. [Wenn Java eine ausdrucksorientierte Sprache wäre, könnten wir hier beliebige Programme hineinlegen.] Mit den Variablen i und j können wir so eine kleine Multiplikationstabelle aufbauen:

for ( int i = 1, j = 9; i <= j; i++, j-- ) 
  System.out.printf( "%d * %d = %d%n", i, j, i*j );

Dann ist die Ausgabe:

1 * 9 = 9 
2 * 8 = 16 
3 * 7 = 21 
4 * 6 = 24 
5 * 5 = 25

Ein weiteres Beispiel mit komplexerer Bedingung wäre das folgende, das vor dem Schleifendurchlauf den Startwert für die Variablen x und y initialisiert, dann x und y heraufsetzt und die Schleife so lange ausführt, bis x und y beide 10 sind.

int x, y; 
for ( x = initX(), y = initY(), x++, y++; 
      ! (x == 10 && y == 10); 
      x += xinc(), y += yinc() ) 
{ 
  // ... 
}

Tipp Komplizierte for-Schleifen sind lesbarer, wenn die drei for-Teile in getrennten Zeilen stehen.



Galileo Computing - Zum Seitenanfang

2.7.4 Schleifenbedingungen und Vergleiche mit == Zur nächsten ÜberschriftZur vorigen Überschrift

Eine Schleifenabbruchbedingung kann ganz unterschiedlich aussehen. Beim Zählen ist es häufig der Vergleich auf einen Endwert. Oft steckt an dieser Stelle ein absoluter Vergleich mit ==, der aus zwei Gründen problematisch werden kann.

Sehen wir uns das erste Problem anhand einiger Programmzeilen an:

int i = ...; 
while ( i != 9 ) 
  i++;

Ist der Wert der Variablen i kleiner als 9, so haben wir beim Zählen kein Problem, denn dann ist anschließend spätestens bei 9 Schluss. Ist der Wert allerdings echt größer als 9, so ist die Bedingung ebenso wahr, und der Schleifenrumpf wird ziemlich lange durchlaufen – genau genommen so weit, bis wir durch einen Überlauf wieder bei 0 beginnen und dann auch bei 9 landen. Die Absicht ist sicherlich eine andere gewesen. Die Schleife sollte nur so lange zählen, wie i kleiner 9 ist, und sonst nicht. Daher passt Folgendes besser:

int i = ...; 
while ( i < 9 ) 
  i++;

Jetzt rennt der Interpreter bei Zahlen größer 9 nicht endlos weiter, sondern stoppt die Schleife sofort.

Rechenungenauigkeiten

Das zweite Problem ergibt sich bei Gleitkommazahlen. Es ist sehr problematisch, echte Vergleiche zu fordern.

double d = 0.0; 
while ( d != 1.0 ) 
{ 
  d += 0.1; 
  System.out.println( d ); 
}

Lassen wir das Programmsegment laufen, so sehen wir, dass die Schleife hurtig über das Ziel hinausschießt:

0.1 
0.2 
0.30000000000000004 
0.4 
0.5 
0.6 
0.7 
0.7999999999999999 
0.8999999999999999 
0.9999999999999999 
1.0999999999999999 
1.2 
1.3

– bis das Auge müde wird ...

Bei Fließkommawerten bietet es sich daher immer an, mit den relationalen Operatoren < oder > zu arbeiten.

Eine zweite Möglichkeit neben dem echten Kleiner/Größer-Vergleich ist, eine erlaubte Abweichung (Delta) zu definieren. Mathematiker bezeichnen die Abweichung von zwei Werten mit dem griechischen Kleinbuchstaben Epsilon. Wenn wir einen Vergleich von zwei Fließkommazahlen anstreben und bei einem Gleichheitsvergleich eine Toleranz mit betrachten wollen, so schreiben wir einfach:

if ( Math.abs(x – y) <= epsilon ) 
  ...

Epsilon ist die erlaubte Abweichung. Math.abs(x) berechnet von einer Zahl x den Absolutwert.

Wie Bereichsangaben schreiben?

Für Bereichsangaben der Form a >= 23 && a <= 42 empfiehlt es sich, den unteren Wert in den Vergleich einzubeziehen, den Wert für die obere Grenze jedoch nicht (inklusive untere Grenzen und exklusive obere Grenzen). Für unser Beispiel, in dem a im Intervall bleiben soll, ist Folgendes besser: a >= 23 && a < 43. Die Begründung dafür ist einleuchtend:

  • Die Größe des Intervalls ist die Differenz aus den Grenzen.
  • Ist das Intervall leer, so sind die Intervallgrenzen gleich.
  • Die untere Grenze ist nie größer als die obere Grenze.

Hinweis Die Standardbibliothek verwendet diese Konvention auch durchgängig, etwa im Fall von substring() bei String-Objekten oder subList() bei Listen oder bei der Angabe von Array-Indexwerten.


Die Vorschläge können für normale Schleifen mit Vergleichen übernommen werden. So ist eine Schleife mit zehn Durchgängen besser in der Form

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

formuliert als in der semantisch äquivalenten Form

for ( i = 0; i <= 9; i++ )

Galileo Computing - Zum Seitenanfang

2.7.5 Ausbruch planen mit break und Wiedereinstieg mit continue Zur nächsten ÜberschriftZur vorigen Überschrift

Wird innerhalb einer for-, while- oder do-while-Schleife eine break-Anweisung eingesetzt, so wird der Schleifendurchlauf beendet und die Abarbeitung bei der ersten Anweisung nach der Schleife fortgeführt.


Beispiel Führe die Schleife so lange durch, bis i den Wert 0 hat.

int i = 10; 
 
while ( true ) 
  if ( i-- == 0 ) 
    break;

Die Anweisung ist nützlich, um im Programmblock festzustellen, ob die Schleife noch einmal durchlaufen werden soll. Sie entlastet den Schleifenkopf, der sonst die Bedingung testen würde. Da ein kleines break jedoch im Programmtext verschwinden könnte, die Bedeutung aber groß ist, sollte ein kleiner Hinweis auf diese Anweisung gesetzt werden.

break lässt sich gut verwenden, um aus einer Schleife vorzeitig auszubrechen, ohne Flags zu benutzen. Dazu ein Beispiel, was vermieden werden sollte:

boolean endFlag = false; 
do 
{ 
  if ( Bedingung ) 
  { 
    // Code ohne Ende 
    endFlag = true; 
  } 
} while ( weitereBedingung && !endFlag );

Stattdessen schreiben wir:

do 
{ 
  if ( Bedingung ) 
  { 
    // Code wieder ohne Ende 
    break; 
  } 
} while ( weitereBedingung );

Die alternative Lösung stellt natürlich einen Unterschied dar, wenn nach dem if noch Anweisungen in der Schleife stehen.

Innerhalb einer for-, while- oder do-while-Schleife lässt sich eine continue-Anweisung einsetzen, die nicht wie break die Schleife beendet, sondern zum Schleifenkopf zurückgeht. Nach dem Auswerten des Fortschaltausdrucks wird im nächsten Schritt erneut geprüft, ob die Schleife weiter durchlaufen werden soll. Ein häufiges Einsatzfeld sind Schleifen, die im Rumpf immer wieder Werte so lange holen und testen, bis diese für die Weiterverarbeitung geeignet sind.


Beispiel Gib die positiven geraden Zahlen von 0 bis 10 aus.

for ( int i = 0; i <= 10; i++ ) 
{ 
  if ( i % 2 == 1 ) 
    continue; 
 
  System.out.println( i + " ist eine gerade Zahl" ); 
}

Manche Programmstücke sind aber ohne continue lesbarer. Ein continue am Ende einer if-Abfrage kann durch einen else-Teil bedeutend klarer gefasst werden. Zunächst das schlechte Beispiel:

while ( Bedingung )       // Durch continue verzuckert 
{ 
  if ( NochNeBedingung ) 
  { 
    // Code,Code,Code 
    continue; 
  } 
  // Weiterer schöner Code 
}

Viel deutlicher ist:

while ( Bedingung ) 
{ 
  if ( NochNeBedingung ) 
  { 
    // Code, Code, Code 
  } 
  else 
  { 
    // Weiterer schöner Code 
  } 
}

Galileo Computing - Zum Seitenanfang

2.7.6 break und continue mit Sprungmarken topZur vorigen Überschrift

Obwohl das Schlüsselwort goto in der Liste der reservierten Wörter auftaucht, ist diese Operation nicht erlaubt. Programmieren mit goto sollte vermieden werden. Mit dem Konzept von break lässt sich gut leben, und es kann auch noch ruhigen Gewissens eingesetzt werden. Doch zum Schrecken vieler kann break noch schmutziger eingesetzt werden, nämlich mit einer Sprungmarke. Das bringt Java verdächtig nahe in die goto-Welt der unstrukturierten Programmiersprachen, was die Entwickler eigentlich vermeiden wollten. Da jedoch Abbruchbedingungen – der häufigste Einsatzort eines goto – vereinzelt auftreten, wurden in Java break und continue mit Sprungmarken eingeführt.

Betrachten wir ein erstes Beispiel, in dem wir mit break bewusst nicht nur aus der inneren Teufelsschleife ausbrechen, sondern aus der äußeren gleich mit.

Listing 2.16 BreakAndContinueWithLabels.java, main()

heaven: 
while ( true ) 
{ 
  hell: 
  while ( true ) 
  { 
    break /* continue */ heaven; 
  } 
  // System.out.println( "hell" ); 
} 
System.out.println( "heaven" );

Ein einfaches break in der inneren while-Schleife beendet nur die Wiederholung, und ein continue würde zur Fortführung dieser inneren while-Schleife führen. Unser Beispiel zeigt jedoch Sprungmarken hinter den Schlüsselwörtern break und continue.

In unserem ersten Beispiel ist die Sprungmarke hell nicht benutzt. Zweitens ist die Zeile mit der Ausgabe »hell« bewusst ausgeklammert, denn sie ist nicht erreichbar und würde andernfalls zu einem Compilerfehler führen. Dass die Anweisung nicht erreichbar ist, ist klar, denn mit einem break heaven kommt das Programm nie zur nächsten Anweisung hinter der inneren Schleife, und somit ist die Konsolenausgabe nicht erreichbar. Setzen wir jedoch statt break heaven ein break hell in die innere Schleife, ändert sich dies:

heaven: 
while ( true ) 
{ 
  hell: 
  while ( true ) 
  { 
    break /* continue */ hell; 
  } 
  System.out.println( "hell" ); 
} 
// System.out.println( "heaven" );

In diesem Szenario ist die Ausgabe »heaven« nicht erreichbar und muss auskommentiert werden. Das break hell in der inneren Schleife wirkt wie ein einfaches break ohne Sprungmarke, und das ablaufende Programm führt laufend zu Bildschirmausgaben »hell«.


Rätsel Warum übersetzt der Compiler Folgendes ohne Murren?

Listing 2.17 WithoutComplain.java

class WithoutComplain 
{ 
  static void main( String[] args ) 
  { 
    http://www.tutego.com/ 
    System.out.print( "Da gibt's Java-Tipps und Tricks." ); 
  } 
}



Ihr Kommentar

Wie hat Ihnen das <openbook> gefallen? Wir freuen uns immer über Ihre freundlichen und kritischen Rückmeldungen.






<< zurück
  Zum Katalog
Zum Katalog: Java ist auch eine Insel





Java ist auch eine Insel
Jetzt bestellen


 Ihre Meinung?
Wie hat Ihnen das <openbook> gefallen?
Ihre Meinung

 Tipp
Zum Katalog: Coding for Fun





 Coding for Fun


 Buchempfehlungen
Zum Katalog: Objektorientierte Programmierung





 Objektorientierte
 Programmierung


Zum Katalog: Einstieg in Eclipse 3.4






 Einstieg in
 Eclipse 3.4


Zum Katalog: Java 6 lernen mit Eclipse






 Java 6 lernen
 mit Eclipse


Zum Katalog: NetBeans Platform 6






 NetBeans
 Platform 6


Zum Katalog: Java und XML






 Java und XML


Zum Katalog: Visual C# 2008






 Visual C# 2008


Zum Katalog: IT-Handbuch für Fachinformatiker






 IT-Handbuch für
 Fachinformatiker


Zum Katalog: C++ von A bis Z






 C++ von A bis Z


 Shopping
Versandkostenfrei bestellen in Deutschland und Österreich
InfoInfo




Copyright © Galileo Press 2009
Für Ihren privaten Gebrauch dürfen Sie die Online-Version natürlich ausdrucken. Ansonsten unterliegt das <openbook> denselben Bestimmungen, wie die gebundene Ausgabe: Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung, Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektronischen Systemen.


[Galileo Computing]

Galileo Press, Rheinwerkallee 4, 53227 Bonn, Tel.: 0228.42150.0, Fax 0228.42150.77, info@galileo-press.de