In Delphi wird diese Programmstruktur in Form der REPEAT..UNTIL..-Anweisung zur Verfügung gestellt:
REPEAT Anweisung UNTIL Bedingung;Dabei wird die Anweisung so lange wiederholt, bis die Bedingung erfüllt ist. Die Bedingung ist also eine Abbruchbedingung. Damit die Schleife nicht endlos wiederholt wird, muss im "Schleifenkörper" (d.h. zwischen "REPEAT" und "UNTIL"} wenigstens eine Anweisung stehen, die die Schleifen-Bedingung beeinflußt. Eine Besonderheit der REPEAT-UNTIL-Schleife von Pascal ist, dass der Schleifenkörper auch aus mehreren Anweisungen bestehen darf, also eine ganze Sequenz sein kann, ohne dass eine Klammerung mit "begin" und "end" nötig wäre: REPEAT Anweisung_1 Anweisung_2 .... .... Anweisung_n UNTIL Bedingung; |
In Java wird diese Programmstruktur in Form der do..while..-Anweisung zur Verfügung gestellt:
do { Anweisung_1 Anweisung_2 ............. Anweisung_n } while (Bedingung);Dabei werden die Anweisungen so lange wiederholt, wie die Bedingung erfüllt ist. Die Bedingung ist also eine Durchführungsbedingung. Damit die Schleife nicht endlos wiederholt wird, muss im "Schleifenkörper" (d.h. zwischen "do" und "while") wenigstens eine Anweisung stehen, die die Schleifen-Bedingung beeinflußt. Wenn Sie tatsächlich mal eine do..while..-Schleife haben sollten, deren Anweisungsblock nur eine einzige Anweisung enthält, dann könnten Sie die geschweiften Klammern um den Block weglassen. Dieser Fall wird allerdings so selten eintreten, dass Sie in aller Regel die blockbildenden Klammern lieber stehen lassen sollten. |
In Delphi könnte der entsprechende algorithmische Kern etwa so aussehen:procedure TForm1.Button1Click(Sender: TObject); var e, s, z : Integer; { Lokale Variablen } begin { Eingabe } z := StrToInt(Edit1.Text); s := StrToInt(Edit2.Text); { Verarbeitung } e := 0; Repeat e := e + s; z := z - 1; until z <= 0; { Abbruchbedingung } { Ausgabe } Edit3.Text := IntToStr(e); end; |
In Java könnte der algorithmische Kern etwa so aussehen:public void button1_ActionPerformed(ActionEvent evt) { /* Eingabe */ int z = Integer.parseInt(textField1.getText()); int s = Integer.parseInt(textField2.getText()); int e = 0; /* Verarbeitung */ do { e = e + s; z = z - 1; { } } while (z > 0); /* Durchführungsbedingung */ /* Ausgabe */ textField3.setText(Integer.toString(e)); } |
In Delphi ist diese Schleife durch die WHILE..DO..-Anweisung realisiert:WHILE Bedingung DO Anweisung;Solange die Bedingung erfüllt ist, wird die Anweisung ausgeführt. Man beachte, dass die Bedingung hier eine Durchführungsbedingung ist, im Gegensatz zur Repeat-Schleife, bei der eine Abbruchbedingung vorliegt. Es gibt noch einen anderen Unterschied: wenn der Schleifenkörper der While-Schleife mehrere Anweisungen enthalten soll, dann müssen diese mit BEGIN....END "geklammert" werden: WHILE Bedingung DO BEGIN Anweisung_1; Anweisung_2; ..... Anweisung_n; END;Bei allen Unterschieden zwischen den beiden Schleifenarten gibt es aber auch Gemeinsames: damit die Schleife nicht endlos wiederholt wird, muss auch im Schleifenkörper der While-Schleife (d.h. zwischen "DO BEGIN" und "END;"} wenigstens eine Anweisung stehen, die die Schleifen-Bedingung beeinflußt. Der wesentliche Unterschied zur "REPEAT..UNTIL.."-Schleife ist, dass die Bedingung bei jener erst nach dem ersten Durcharbeiten des Schleifenblocks getestet wird, bei der "WHILE..DO.."-Schleife jedoch schon vor diesem ersten Durchlauf. Mithin gilt für die Anzahl n der Durchläufe des Anweisungsblocks bei einer "REPEAT..UNTIL.."-Schleife die Ungleichung "n >= 1", während bei der "WHILE..DO.."-Schleife gilt "n >= 0". Das mag Ihnen als ein eher kleiner Unterschied erscheinen, kann aber beim Programmieren weitreichende und gelegentlich auch katastrophale Folgen haben. |
In Java ist diese Schleife durch die while...-Anweisung realisiert:while (Bedingung) { Anweisung_1; Anweisung_2; ..... Anweisung_n; }Solange die Bedingung erfüllt ist, werden die Anweisungen ausgeführt. Man beachte, dass auch hier die Bedingung eine Durchführungsbedingung ist. Damit die Schleife nicht endlos wiederholt wird, muss auch im Schleifenkörper der while-Schleife wenigstens eine Anweisung stehen, die die Schleifen-Bedingung beeinflusst. Deshalb folgt nach der Bedingung gleich ein ganzer Block, der mit { und } geklammert ist. Der Fall, dass Sie diese Klammern weglassen können, weil der Schleifenkörper nur 1 Anweisung enthält, wird in der Praxis so selten auftauchen, dass Sie sich ohne Schaden angewöhnen können, die Blockmarkierungen grundsätzlich stehen zu lassen - so wie sie von vielen Java-Editoren ja schon während der Eingabe vorausschauend ergänzt werden. Der wesentliche Unterschied zur "do..while.."-Schleife ist, dass die Bedingung bei jener erst nach dem ersten Durcharbeiten des Schleifenblocks getestet wird, bei der "while.."-Schleife jedoch schon vor diesem ersten Durchlauf. Mithin gilt für die Anzahl n der Durchläufe des Anweisungsblocks bei einer "do..while.."-Schleife die Ungleichung "n >= 1", während bei der "while.."-Schleife gilt "n >= 0". Das mag als ein eher kleiner Unterschied erscheinen, kann aber beim Programmieren weitreichende und gelegentlich auch katastrophale Folgen haben. |
In Delphi erstellen Sie dazu ein neues Verzeichnis und kopieren dorthinein die DPR-, die DFM- und die PAS-Datei des alten Projekts. Laden Sie dann die DPR-Datei aus dem neuen Verzeichnis, benennen Sie das Projekt um und speichern Sie alle Dateien nochmals ab. Im Kopf des Delphi-Editor-Fensters dürfen danach keine relativen Pfade mehr erscheinen! Entwickeln Sie das Projekt dann weiter. Dies können Sie auf zwei verschiedene Arten machen:
|
In Java erstellen Sie dazu ein neues Verzeichnis und kopieren dorthinein die JAVA- und die JFM-Datei des alten Projekts. Laden Sie dann die JFM-Datei aus dem neuen Verzeichnis in den "JavaEditor", wobei dieser auch gleich die zugehörige JAVA-Datei lädt. Benennen Sie das Projekt um, indem Sie den Namen des Formulars ändern und danach alle Dateien (unter dem neuen Namen!) nochmals abspeichern. Entwickeln Sie das Projekt dann weiter. Dies können Sie auf zwei verschiedene Arten machen:
|
Delphi kennt schon von Haus aus die Verknüpfungen "DIV" und "MOD": wir können sie in Termen genau so einsetzen wie "+", "-" oder "*". Voraussetzung ist, dass diese Ganzzahl-Operatoren nur auf INTEGER-Zahlen angewendet werden. Den Versuch, "3.2 MOD 8" berechnen zu wollen, quittiert schon der Delphi-Compiler mit einer Fehlermeldung. Die Syntax für diese beiden neuen Rechenarten ist:
|
Java kennt schon von Haus aus die Verknüpfungen "DIV" und "MOD": wir können sie in Termen genau so einsetzen wie "+", "-" oder "*". Die Syntax für diese beiden neuen Rechenarten ist:
Wenn Sie "a / b" berechnen lassen, hängt das Ergebnis vom Typ der beteiligten Variablen ab: ist wenigstens eine Fließkommazahl dabei, dann wird die "normale" Division ausgeführt; sind beide Zahlen von einem ganzzahligen Typ, dann wird "a DIV b" berechnet und das Ergebnis als ganze Zahl (also z.B. int) zurückgegeben. Wenig sinnvoll hingegen ist, dass Java erlaubt, den Ganzzahl-Operator MOD auch auf Fließkommazahlen anzuwenden: schließlich hat die "normale Division" eigentlich keinen Rest! Wenn a und b hingegen beide ganzzahlig sind, dann liefert "a % b" den korrekten ganzzahligen Wert von "a MOD b". |