Arrays, Bedingungen und Schleifen
von Laura Lemay
Was Sie bisher gelernt haben, würde zwar genügen, um Java-Programme zu schreiben, jedoch wären diese Programme ziemlich eintönig. Die Leckerbissen können in Java oder auch einer anderen Programmiersprache erreicht werden, wenn man Arrays hat, um Werte darin zu speichern, sowie Schleifen und Bedingungen, um verschiedene Teile des Programms auszuführen. Heute lernen Sie folgendes:
Arrays sind in Java anders als in anderen Sprachen. In Java sind Arrays Objekte, die herumgereicht und wie andere Objekte behandelt werden können.
Ein Array ist eine Möglichkeit, eine Liste von Elementen zu speichern. Jedes Elements des Arrays wird einzeln gespeichert und kann nach Bedarf eingefügt und entfernt werden.
Arrays können jeden Wertetyp (Basistypen oder Objekte) enthalten, jedoch können in einem Array nicht unterschiedliche Typen gespeichert werden. Sie können ein Array für Ganzzahlen, Zeichenketten oder Arrays anlegen, jedoch keines, das mehrere Typen mischt.
In Java umfaßt das Erstellen eines Arrays drei Schritte:
1. Deklarieren einer Variablen zur Aufnahme des Arrays 2. Erstellen eines neuen Array-Objekts und Zuweisen einer Array-Variablen 3. Speichern von Elementen im Array
Der erste Schritt beim Anlegen eines Arrays ist das Erstellen einer Variablen, die das Array aufnimmt. Das geschieht genauso wie bei anderen Variablen. Array-Variablen zeigen den Objekttyp an, den das Array aufnimmt (wie bei jeder Variablen), und den Namen des Arrays, gefolgt von leeren eckigen Klammern ([]). Nachfolgend typische Deklarationen von Array-Variablen:
String difficultWords[]; Point hits[]; int temps[];
Alternativ kann eine Array-Variable definiert werden, indem die Klammern nicht nach der Variablen, sondern nach dem Typ eingefügt werden. Das hat die gleiche Wirkung, macht aber den Code meist besser lesbar. Die obigen drei Deklarationen würden nach dieser Methode so aussehen:
String[] difficultWords; Point[] hits; int[] temps;
Im zweiten Schritt wird ein Array-Objekt erstellt und dieser Variablen zugewiesen. Das kann auf zwei Arten erfolgen:
Bei der ersten Art wird der Operator new benutzt, um eine neue Instanz eines Arrays zu erstellen:
String[] names = new String[10];
Diese Zeile erstellt ein neues Array von Strings mit zehn Schlitzen bzw. Elementen. Beim Erstellen eines neuen Array-Objektes mit new müssen Sie angeben, wie viele Elemente das Array aufnehmen soll.
Array-Objekte können primitive Typen wie Ganzzahlen oder boolesche Operatoren oder Objekte enthalten:
int[] temps = new int[99];
Beim Erstellen eines Array-Objekts mit new werden alle Elemente des Arrays automatisch initialisiert (0 für numerische Arrays, false für boolesche, '\0' für Zeichen-Arrays und null für alles andere). Sie können ein Array auf die gleiche Weise manuell erstellen und initialisieren. Anstelle der Verwendung von new schließen Sie die Elemente des Arrays in Klammern ein und trennen sie durch Kommas:
String[] chiles = { "jalapeno", "anaheim", "serrano", "habanero", "thai" };
Alle innerhalb der Klammern stehenden Elemente müssen vom gleichenTyp sein, der dem Typ der Variablen entsprechen muß, die das Array enthält. Ein Array wird mit der Zahl der Elemente, die Sie angegeben haben, automatisch erstellt. Dieses Beispiel erstellt ein Array mit String-Objekten namens chiles, die fünf Elemente enthalten.
Nachdem Sie ein Array mit Anfangswerten erstellt haben, können Sie es testen und die Werte der einzelnen Zellen des Arrays ändern. Um einen Wert in einem Array zu speichern, benutzen Sie den Array-Ausdruck subscript:
myArray[subscript];
Der Teil myArray dieses Audrucks ist eine Variable, die ein Array-Objekt beinhaltet, kann aber auch ein Ausdruck sein, der ein Array ergibt. subscript ist der Schlitz, in dem auf das Array zugegriffen wird, was ebenfalls ein Ausdruck sein kann. Array-Subscripts beginnen mit 0 wie in C und C++. Ein Array mit zehn Elementen hat folglich Array-Werte von Subscript 0 bis 9.
Alle Array-Subscripts werden geprüft, um sicherzustellen, daß sie sich innerhalb der Grenzen des Arrays befinden (größer als 0, aber kleiner als die Array-Länge). Das geschieht beim Kompilieren des Java-Programms oder bei dessen Ausführung. In Java ist es nicht möglich, einem Array-Element einen Wert zuzuweisen, der außerhalb der Grenzen des Arrays liegt. Beachten Sie beispielsweise folgende Anweisungen:
String arr[] = new String[10]; arr[10] = "eggplant";
Die zweite Anweisung führt zu einem Kompilierfehler. Das in arr gespeicherte Array hat nur zehn ab 0 numerierte Elemente. In Subscript 10 ist kein Element vorhanden. Deshalb würde dieses Programm nicht kompiliert werden.
Wird das Array-Subscript zur Laufzeit berechnet (z. B. als Teil einer Schleife) und endet es außerhalb der Array-Grenzen, erzeugt der Java-Interpreter ebenfalls einen Fehler (genauer gesagt, weist er auf eine Ausnahme hin). Sie lernen nächste Woche am 18. Tag alles über Ausnahmen.
Wie kann man verhindern, daß ein Array versehentlich in einem Programm überläuft? Sie können die Länge eines Arrays in Ihren Programmen mit der Instanzvariablen length testen. Sie ist für alle Array-Objekte, ungeachtet des Typs, verfügbar:
int len = arr.length; // gibt 10 aus
Um einer bestimmten Array-Zelle einen Wert zuzuweisen, setzen Sie einfach eine Zuweisungsanweisung hinter den Zugriffsausdruck des Arrays:
myarray[1] = 15; sentence[0] = "The"; sentence[10] = sentence[0];
Wichtig ist hier die Feststellung, daß ein Array mit Objekten in Java Referenzen auf diese Objekte enthält (ähnlich wie ein Pointer-Array in C oder C++). Wenn Sie einem Array-Schlitz einen Wert zuweisen, erstellen Sie eine Referenz auf das betreffende Objekt wie bei einer einfachen Variablen. Verschieben Sie Werte in Arrays (wie beispielsweise in der letzten Zeile oben), weisen Sie die Referenz erneut zu. Sie kopieren also nicht den Wert von einem Schlitz in einen anderen. Arrays mit primitiven Typen wie int oder float kopieren aber die Werte von einem Schlitz in einen anderen.
Arrays mit Referenzen auf Objekte, anstelle der Objekte selbst, sind besonders nützlich, weil das bedeutet, daß Sie mehrere Referenzen auf das gleiche Objekt innerhalb und außerhalb von Arrays definieren können. So können Sie z. B. ein Objekt, das in einem Array enthalten ist, einer Variablen zuweisen und auf dieses Objekt über die Variable oder die Array-Position verweisen.
In Java werden multidimensionale Arrays nicht unterstützt. Allerdings können Sie ein Array mit Arrays (die wiederum Arrays enthalten können usw., über beliebig viele Dimensionen) deklarieren und darauf zugreifen wie auf C-artige multidimensionale Arrays:
int coords[] [] = new int[12][12]; coords[0][0] = 1; coords[0][1] = 2;
Eine Blockanweisung ist eine Gruppe anderer Anweisungen, die zwischen geschweiften Klammern ({}) stehen. Sie können einen Block überall dort verwenden, wo eine einzelne Anweisung stehen kann. Der neue Block erstellt einen neuen lokalen Bereich für die darin befindlichen Anweisungen. Das bedeutet, daß Sie lokale Variablen in einem Block deklarieren und benutzen können. Diese Variablen existieren nicht mehr, nachdem der Block vollständig ausgeführt wurde. Nachfolgend ein Beispiel eines Blocks in einer Methodendefinition, die die neue Variable y deklariert. Sie können y außerhalb des Blocks, in dem sie deklariert ist, verwenden:
void testblock() {
int x = 10;
{ // start of block
int y = 50;
System.out.println("inside the block:");
System.out.println("x:" + x);
System.out.println("y:" + y);
} // end of block
}
Blöcke werden normalerweise aber nicht auf diese Weise - allein in einer Methodendefinition - verwendet. Vorwiegend haben Sie bisher Blöcke gesehen, die Klassen- und Methodendefinitionen umgeben. Daneben gibt es eine andere häufige Verwendung für Blockanweisungen, über die Sie später in der heutigen Lektion mehr erfahren.
Die if-Bedingung, die die Ausführung verschiedener Codeteile anhand eines einfachen Tests in Java ermöglicht, ist fast mit der if-Anweisung in C identisch. if-Bedingungen enthalten das Schlüsselwort if, gefolgt von einem booleschen Test, gefolgt von einer Anweisung (meist eine Blockanweisung), um die Ausführung zu veranlassen, wenn der Test wahr ist:
if (x < y)
System.out.println("x is smaller than y");
Ein optionales else-Schlüsselwort veranlaßt die Ausführung der Anweisung, wenn der Test falsch ist:
if (x < y)
System.out.println("x is smaller than y");
else System.out.println("y is bigger.");
Der Unterschied zwischen if in Java und C oder C++ ist, daß der Test einen booleschen Wert (true oder false) ausgeben muß. Im Gegensatz zu C kann der Test keine Ganzzahl ergeben.
if (engineState == true )
System.out.println("Engine is already on.");
else {
System.out.println("Now starting engine");
if (gasLevel >= 1)
engineState = true;
else System.out.println("Low on gas! Can't start Engine.");
}
In diesem Beispiel wird der Test (engineState == false) benutzt. Bei booleschen Tests dieser Art wird als Kurzform üblicherweise lediglich der erste Teil des Ausdrucks eingebunden, anstelle des expliziten Prüfens seines Wertes auf wahr oder falsch:
if (engineState)
System.out.println("Engine is on.");
else System.out.println("Engine is off.");
Eine Alternative zur Verwendung der Schlüsselwörter if und else in einer Bedingungsanweisung ist der Bedingungsoperator, der auch ternärer Operator genannt wird.
Ein Bedingungsoperator ist ein ternärer Operator, weil er drei Begriffe umfaßt.
Der Bedingungsoperator ist ein Ausdruck, was bedeutet, daß er einen Wert ausgibt (im Gegensatz zum allgemeineren if, das zur Ausführung einer beliebigen Anweisung oder eines Blocks führen kann). Der Bedingungsoperator ist besonders für sehr kurze oder einfache Bedingungen nützlich und sieht so aus:
test ? trueresult : falseresult
Das Wort test ist ein Ausdruck, der true oder false ausgibt, wie beim Testen in der if-Anweisung. Ist der Test wahr, gibt der Bedingungsoperator den Wert von trueresult aus. Ist er falsch, gibt er den Wert von falseresult aus. Folgende Bedingung prüft die Werte von x und y, gibt den kleineren der beiden Werte aus und weist diesen Wert der Variablen smaller zu:
int smaller = x < y ? x : y;
Der Bedingungsoperator hat eine sehr niedrige Präzedenz. Das bedeutet, daß er normalerweise erst nach allen Unterausdrücken bewertet wird. Nur die Zuweisungsoperatoren haben eine noch niedrigere Präzedenz. Zum Auffrischen des Gedächtnisses können Sie die Präzedenz von Operatoren in Tabelle 3.7 nachschlagen.
Eine übliche Vorgehensweise beim Programmieren in jeder Sprache ist das Testen einer Variablen auf einen bestimmten Wert. Falls sie nicht zu diesem Wert paßt, wird sie anhand eines anderen Wertes geprüft, und falls dieser wieder nicht paßt, wird wieder mit einem anderen Wert geprüft usw. Werden nur if-Anweisungen verwendet, kann das je nach dem, wie formatiert wurde und wie viele verschiedene Optionen geprüft werden müssen, sehr unhandlich sein. Zum Schluß können sich if-Anweisungen wie im folgenden Beispiel oder noch mehr anhäufen:
if (oper == '+') addargs(arg1,arg2); else if (oper == '=') subargs(arg1,arg2); else if (oper == '*') multargs(arg1,arg2); else if (oper == '/') divargs(arg1,arg2);
Diese Form nennt man angehäufte if-Anweisungen, weil jede else-Anweisung ihrerseits weitere if-Anweisungen enthält, bis alle möglichen Tests ausgeführt wurden.
Eine übliche Kurzform anstelle angehäufter if-Anweisungen ermöglicht Ihnen in manchen Fällen, Tests und Aktionen gemeinsam in einer Anweisung auszuführen. Das ist die Anweisung switch oder case. In Java ist es die Anweisung switch, die sich wie in C verhält:
switch (test) {
case valueOne:
resultOne;
break;
case valueTwo:
resultTwo;
break;
case valueThree:
resultThree;
break;
...
default:defaultresult;
}
Durch die switch-Anweisung wird der Text (ein primitiver Typ wie byte, char, short oder int) mit jedem einzelnen Fallwert nacheinander verglichen. Wird eine Übereinstimmung vorgefunden, werden die betreffenden Anweisungen nach dem Test ausgeführt. Gibt es keine Übereinstimmung, wird die Anweisung default ausgeführt. Da default optional ist, wird die switch-Anweisung komplett ausgeführt, ohne etwas zu bewirken, wenn in keinem Fall eine Übereinstimmung vorliegt und default nicht existiert.
Eine erhebliche Einschränkung von switch in Java ist die, daß die Tests und Werte nur auf sehr einfache Primitivtypen anwendbar sind (und auch dann nur Primitivtypen, deren Casting in int möglich ist). In switch können keine größeren primitiven Typen (long, float) oder Objekte benutzt werden. Außerdem können, abgesehen von Gleichheit, keine Beziehungen geprüft werden. Das schränkt die Brauchbarkeit von switch auf die absolut einfachsten Fälle ein. Demgegenüber sind angehäufte if-Anweisungen auf jede Art der Prüfung jedes Typs anwendbar.
Hier noch einmal das obige Beispiel, diesmal jedoch mit einer switch-Anweisung anstelle angehäufter if-Anweisungen:
switch (oper) {
case '+':
addargs(arg1,arg2);
break;
case '*':
subargs(arg1,arg2);
break;
case '-':
multargs(arg1,arg2);
break;
case '/':
divargs(arg1,arg2);
break;
}
Beachten Sie die Anweisung break in jeder Zeile. Ohne explizites break werden die Anweisungen zur Suche nach einer Übereinstimmung und alle nachfolgenden Anweisungen innerhalb von switch so lange ausgeführt, bis ein break oder das Ende von switch erreicht ist (danach wird die Ausführung nach dem Ende von switch fortgesetzt). In manchen Fällen ist das genau das, was man bezwecken will. In dem meisten Fällen ist es jedoch sinnvoller, nach jeder Zeile break einzufügen, damit nur die gewünschten Anweisungen ausgeführt werden.
Eine handliche Verwendung ist möglich, wenn mehrere Werte die gleiche Anweisung ausführen sollen. In diesem Fall können Sie mehrere Fallzeilen ohne Ergebnis eingeben, dann führt switch die ersten Anweisungen aus, die es findet. In der folgenden switch-Anweisung wird beispielsweise die Zeichenkette "x is an even number." ausgegeben, wenn x einen geraden Wert, z. B. 2, 4, 6 oder 8, hat. Alle anderen Werte von x geben die Zeichenkette "x is an odd number." aus.
switch (x) {
case 2:
case 4:
case 6:
case 8:
System.out.println("x is an even number.");
break;
default: System.out.println("x is an odd number.");
}
Wie in C wiederholt die for-Schleife eine Anweisung oder einen Anweisungsblock mehrmals, bis eine Bedingung zutrifft. for-Schleifen werden häufig für einfache Wiederholungen verwendet, um Blockanweisungen mehrmals auszuführen und dann zu stoppen. Sie können for-Schleifen aber auch nur für eine bestimmte Schleifenart verwenden.
Die for-Schleife sieht in Java so aus:
for (initialization; test; increment) {
statements;
}
Der Beginn der for-Schleife hat drei Teile:
Der statement-Teil der for-Schleife ist die Anweisung, die bei jeder Wiederholung der Schleife ausgeführt wird. Wie bei if können Sie hier entweder eine einzelne Anweisung oder einen Block einbinden. Im vorherigen Beispiel wurde ein Block benutzt, weil das üblich ist. Im nächsten Beispiel einer for-Schleife werden alle Werte eines String-Arrays auf null-Zeichenketten initialisiert:
String strArray[] = new String[10]; int i; // loop index for (i = 0; i < strArray.length; i++) strArray[i] = "";
Jeder Teil der for-Schleife kann eine leere Anweisung sein, d. h. Sie können einfach ein Semikolon ohne Ausdruck oder Anweisung eingeben, dann wird dieser Teil der for-Schleife ignoriert. Wenn Sie in einer for-Schleife eine Null-Anweisung verwenden, müssen Sie eventuell Schleifenvariablen oder Schleifenindizes manuell anderswo im Programm initialisieren oder inkrementieren.
Auch im Körper der for-Schleife kann eine leere Anweisung stehen, falls alles, was Sie bezwecken, in der ersten Zeile der Schleife steht. Im folgenden Beispiel wird die erste Primzahl gesucht, die höher ist als 4000:
for (i = 4001; notPrime(i); i += 2) ;
Beachten Sie, daß ein häufig in C gemachter Fehler auch in Java passieren kann: Nach der ersten Zeile der for-Schleife wird versehentlich kein Semikolon eingegeben:
for (i = 0; i < 10; i++);
System.out.println("Loop!");
Da das erste Semikolon die Schleife mit einer leeren Anweisung beendet, bewirkt die Schleife im Grunde nichts. Die Funktion println wird nur einmal ausgegeben, weil sie sich außerhalb der for-Schleife befindet. Achten Sie darauf, daß Ihnen dieser Fehler in Ihren Java-Programmen nicht passiert.
In Java gibt es auch die Schleifen while und do. Wie mit for-Schleifen kann damit ein Teil eines Java-Codes wiederholt ausgeführt werden, bis eine bestimmte Bedingung erfüllt ist. Welche der drei Schleifenarten Sie bevorzugt verwenden, ist eine Sache des persönlichen Programmierstils.
Wie for sind auch die Schleifen while und do mit denen in C und C++ identisch.
Die while-Schleife wird zum Wiederholen einer Anweisung oder Blockanweisungen, bis eine bestimmte Bedingung zutrifft, verwendet. while-Schleifen sehen in Java so aus:
while (condition) {
bodyOfLoop;
}
condition ist ein boolescher Ausdruck. Trifft er zu, d. h. ergibt sich true, führt die while-Schleife die in bodyOfLoop stehenden Anweisungen aus und prüft dann die Bedingung erneut so oft, bis die Bedingung falsch ist. Ich habe hier die while-Schleife mit einer Blockanweisung aufgeführt, weil das die übliche Verwendung ist. Anstelle eines Blocks kann aber auch eine einzelne Anweisung stehen.
Das nächste Beispiel ist eine while-Schleife, die die Elemente eines Arrays mit Ganzzahlen (in array1) in ein Array mit Gleitpunktzahlen (in array2) kopiert. Dabei werden alle Elemente nacheinander in float konvertiert. Ist eines der Elemente im ersten Array 0, beendet die Schleife sofort an diesem Punkt. Um beide Fälle abzudecken, d. h. alle Elemente sollen kopiert und ein Element soll 0 sein, kann mit dem Operator && ein Verbundtest angewandt werden:
int count = ø;
while ( count < array1.length && array1[count] !=ø) {
array2[count] = (float) array1[count++];
}
Falls die Bedingung beim ersten Durchlauf falsch ist (z. B. wenn das erste Element im ersten Array 0 ist), wird der Körper der while-Schleife nie ausgeführt. Soll die Schleife mindestens einmal ausgeführt werden, haben Sie folgende Möglichkeiten:
Die do-Schleife gilt als bessere Lösung der zwei Möglichkeiten.
Die do-Schleife ist wie die while-Schleife, außer daß sie eine bestimmte Anweisung oder einen Block so oft ausführt, bis eine Bedingung falsch ist. Der wesentliche Unterschied ist, daß while-Schleifen die Bedingung vor der Ausführung der Schleife prüfen, so daß der Schleifenkörper unter Umständen nie ausgeführt wird, wenn die Bedingung beim ersten Durchlauf falsch ist, während bei do-Schleifen der Schleifenkörper mindestens einmal vor dem Testen der Bedingung ausgeführt wird. do-Schleifen sehen in Java so aus:
do {
bodyOfLoop;
} while (condition);
Hier beinhaltet der Teil bodyOfLoop die Anweisungen, die bei jeder Wiederholung ausgeführt werden. In diesem Beispiel wurde eine Blockanweisung verwendet, da dies die übliche Art ist. Sie können die Klammern aber auch durch eine einzelne Anweisung ersetzen. Die Bedingung ist ein boolescher Test. Ergibt sich true, wird die Schleife erneut ausgeführt. Ergibt sich false, wird die Schleife beendet. Denken Sie daran, daß der Schleifenkörper bei do-Schleifen mindestens einmal ausgeführt wird.
Im folgenden einfachen Beispiel einer do-Schleife wird eine Meldung jedesmal ausgegeben, wenn die Schleife wiederholt wird:
int x = 1;
do {
System.out.println("Looping, round " + x);
x++;'
} while (x <= 10);Im folgenden die Ausgabe dieser Anweisungen: Alle Schleifen (for, while und do) enden, wenn die geprüfte Bedingung erfüllt ist. Was passiert, wenn etwas Seltsames im Schleifenkörper stattfindet und Sie die Schleife frühzeitig beenden wollen? Hierfür können Sie die Schlüsselwörter break und continue verwenden.
Sie haben break bereits als Teil der switch-Anweisung kennengelernt. break stoppt die Ausführung von switch und das Programm läuft weiter. Bei Verwendung mit einer Schleife bewirkt das Schlüsselwort break das gleiche - es hält die Ausführung der aktiven Schleife sofort an. Enthalten Schleifen verschachtelte Schleifen, wird die Ausführung mit der nächstäußeren Schleife wieder aufgenommen. Andernfalls wird die Ausführung des Programms ab der nächsten Anweisung nach der Schleife fortgesetzt.
Nehmen wir als Beispiel an, Sie haben eine while-Schleife, die Elemente von einem Array in ein anderes kopiert. Jedes Element im Array soll kopiert werden, bis das Ende des Arrays erreicht ist oder bis ein Element 0 enthält. Sie können den zweiten Fall im while-Körper testen und dann break verwenden, um die Schleife zu beenden:
continue ist ähnlich wie break, außer, daß die Ausführung der Schleife nicht komplett gestoppt wird, sondern mit der nächsten Wiederholung erneut beginnt. Bei do- und while-Schleifen bedeutet das, daß die Ausführung des Blocks erneut beginnt. Bei for-Schleifen wird der Ausdruck increment bewertet, dann wird der Block ausgeführt. continue ist nützlich, wenn Sie mit speziellen Fallelementen in einer Schleife arbeiten. Mit dem vorherigen Beispiel, in dem ein Array in ein anderes kopiert wird, können Sie testen, ob das aktuelle Element 0 ist, und die Schleife neu starten, falls dies zutrifft, so daß das resultierende Array nie Null enthält. Da dabei Elemente im ersten Array übersprungen werden, müssen Sie folglich die zwei verschiedenen Array-Zähler überwachen:
Sowohl break als auch continue kann wahlweise beschriftet werden, um Java mitzuteilen, wo genau unterbrochen werden soll. Ohne Beschriftung springt break außerhalb der nächsten Schleife (auf eine zwischen Klammern stehende Schleife oder zur nächsten Anweisung außerhalb der Schleife), während continue ab der in Klammern stehenden Schleife wieder beginnt. Durch Verwendung beschrifteter break- und continue-Schlüsselwörter können Sie außerhalb von verschachtelten Schleifen unterbrechen oder eine Schleife außerhalb der aktiven Schleife fortsetzen.
Um eine Schleife zu benennen, fügen Sie vor dem Anfangsteil der Schleife eine Beschriftung (Label) und einen Doppelpunkt ein. Wenn Sie dann break oder continue verwenden, fügen Sie den Namen der Beschriftung direkt nach dem Schlüsselwort ein:
In diesem Codeteilchen wird die äußere for-Schleife mit out bezeichnet. Ein break innerhalb der for- und der while-Schleife veranlaßt die Unterbrechung beider Schleifen, falls eine bestimmte Bedingung in beiden Schleifen erfüllt ist, und startet wieder ab der Beschriftung (out).
Das folgende kleine Programm ist ein weiteres Beispiel mit einer verschachtelten for-Schleife. Beide Schleifen werden sofort beendet, wenn die Summenwerte der zwei Zähler in der innersten Schleife größer sind als vier:
Die Ausgabe dieses Programms ist wie folgt:
Heute haben Sie drei wichtige Themen gelernt, die Sie höchstwahrscheinlich oft in Ihren Java-Programmen anwenden werden: Arrays, Bedingungen und Schleifen.
Sie haben gelernt, wie eine Array-Variable deklariert wird, wie ein Array-Objekt erstellt und dieser Variablen zugewiesen wird und wie Sie auf Elemente in einem Array zugreifen und diese ändern.
Zu Bedingungen zählen die Anweisungen if und switch, mit denen Sie auf der Grundlage eines booleschen Tests in andere Teile eines Programms verzweigen können.
Ferner haben Sie die Schleifen for, while und do gelernt. Mit allen drei Schleifenarten können Sie einen Programmteil wiederholt ausführen, bis eine bestimmte Bedingung erfüllt ist.
Sie haben damit zahlreiche Kleinigkeiten gelernt, so daß Sie sich jetzt größeren Themen zuwenden können. Sie sollten heute früh schlafen gehen, denn morgen erwartet Sie ein harter Tag. Unter anderem werden Sie Klassen deklarieren und Methoden erstellen, in denen Instanzen jener Klassen miteinander durch Aufrufmethoden kommunizieren.
F: Da Arrays, wie Sie sagen, Objekte sind und new angewandt wird, um sie zu erstellen, und da sie eine Instanz mit der Variablen length haben, verstehe ich nicht, warum es in der Java-Klassenbibliothek keine Array-Klasse gibt.
A: Arrays werden in Java auf seltsame Weise implementiert. Die Array-Klasse wird automatisch gebildet, wenn Ihr Java-Programm ausgeführt wird. Array bildet den Grundrahmen für Arrays, einschließlich der Variablen length. Zusätzlich hat jeder Primitivtyp und jedes Objekt eine implizite Subklasse von Array, die ein Array der jeweiligen Klasse oder des Objekts darstellt. Wenn Sie ein neues Array-Objekt erstellen, hat es eventuell keine Klasse, verhält sich aber so, als hätte es eine.
F: Gibt es in Java kein goto ?
A: Die Java-Sprache definiert das Schlüsselwort goto, jedoch wird es derzeit nicht verwendet. Das heißt mit anderen Worten: Java hat kein goto.
F: Ich habe in einer Blockanweisung für ein if eine Variable deklariert. Als das if fertig war, verschwand die Definition dieser Variablen. Wie kann das sein?
A: Vom technischen Gesichtspunkt bilden Blockanweisungen innerhalb von Klammern einen neuen
semantischen Bereich. Das bedeutet, daß eine in einem Block deklarierte Variable nur innerhalb dieses Blocks sichtbar und nutzbar ist. Sobald die Ausführung des Blocks abgeschlossen ist, verschwinden alle Variablen, die Sie deklariert haben.
Es empfiehlt sich, Variablen im äußersten Block, in dem sie gebraucht werden, zu deklarieren. Das ist normalerweise am Anfang einer Blockanweisung. Eine Ausnahme hierzu können sehr einfache Variablen sein, z. B. Indexzähler in for-Schleifen, deren Deklaration in der ersten Zeile der for-Schleife eine einfache Kurzform ist.
Sie lernen morgen mehr über Variablen und Bereiche.
F: Warum kann man switch nicht mit Zeichenketten benutzen?
A: Zeichenketten sind Objekte, während switch in Java nur auf die primitiven Typen angewandt werden kann, die in Ganzzahlen konvertiert werden können (byte, char, short und int). Zum Vergleichen von Zeichenketten müssen Sie angehäufte if-Anweisungen verwenden. Damit sind auch Vergleiche von Zeichenketten möglich.
F: Mir scheint, daß ein Großteil der for-Schleifen als while-Schleifen geschrieben werden kann, und umgekehrt. Stimmt das?
A: Ja, das stimmt. Die for-Schleife ist eigentlich ein Sonderfall von while, der es Ihnen ermöglicht, eine Schleife in einer bestimmten Häufigkeit zu wiederholen. Sie können das genauso gut mit while erreichen, müßten aber dann einen Zähler in der Schleife erhöhen. Beides funktioniert gleich gut. Im wesentlichen ist das eine Frage des Programmierstils und der persönlichen Vorlieben.
Looping, round 1
Looping, round 2
Looping, round 3
Looping, round 4
Looping, round 5
Looping, round 6
Looping, round 7
Looping, round 8
Looping, round 9
Looping, round 10
Unterbrechen von Schleifen
while (count < array1.length) {
if (array1[count] == 0) {
break;
}
array2[count] = array1[count];
count++;
}
while (count < array1.length) {
if (array1[count] == 0)
array2[count2++] = (float)array1[count++];
}
Benannte Schleifen
out:
for (int i = 0; i <10; i++) {
while (x < 50) {
if (i * x == 400)
break out;
...
}
...
}
foo:
for (int i = 1; i <= 5; i++)
for (int j = 1; j <= 3; j++) {
System.out.println("i is " + i + ", j is " + );
if ((i + j) > 4)
break foo;
}
System.out.println("end of loops");
i is 1, j is 1
i is 1, j is 2
i is 1, j is 3
i is 2, j is 1
i is 2, j is 2
i is 2, j is 3
end of loops
Wie Sie sehen, wird die Schleife so oft wiederholt, bis die Summe von i und j größer ist als 4, dann enden beide Schleifen, führen zum äußeren Block zurück und die endgültige Meldung wird ausgegeben.Zusammenfassung
Fragen und Antworten
Buch- und Software- Verlag GmbH
Alle Rechte vorbehalten. All rights reserved.