Hallo sayuri, der Code ist - ich sag mal - seltsam. 1. die Zuweisung von a vor der for-Schleife ist überflüssig. a wird ja beim Start der for-Schleife auf 3 gesetzt. Da ist also die vorherige Zuweisung total egal. 2. die Schleifenvariable, hier a, wird immer am Ende der for-Schleife "bearbeitet". In diesem Fall a+1 wegen a++. Die Zuweisung a=a++ braucht es an dieser Stelle auch nicht. a++ hätte gereicht. 3. Denkfehler. Das Ergebnis der Ausgabe ist nur 2 und 4, 3 kommt nicht vor. Warum nicht? Weil in der for-Schleife die Schleifenvariable mit a=a+1 zusätzlich manipuliert wird. Also wird a zweimal erhöht. Somit kommt 3 nicht vor, weil a mit 3 startet, dann 5 wird und beim dritten Durchlauf 7 erreicht was das Ende der for Schleife bedeutet. Grundsätzlich gilt für for Schleifen folgendes: Als erstes wird die Schleifenvariable zugewiesen, dann wird die Abbruchbedingung geprüft und am Ende der Schleife die Schleifenvariable „bearbeitet“. Jede der 3 Anweisungen ist separat zu betrachten und kann auch weggelassen werden. So stellt z.B. die Schleife for(;;) {…} ganz einfach eine Endlosschleife dar. So, ich hoffe ich habe dich jetzt genug verwirrt ;-) Gruss jobe.

Die Post-Inkrementierung von a im Schleifenkopf vor der Zuweisung führt dazu das der Wert verworfen wird. Deshalb die Ausgabe 2, 3, 4. Was Jobe unter seinem dritten Punkt schreibt ist dementsprechend nicht ganz richtig. Und unter C wäre es BTW dasselbe wie in Java. ;-)

Was mich aber wirklich wundert: es werden hier die Laufvariablen im Kopf und nochmal zusätzlich innerhalb der Schleife manipuliert, unnötig Referenzierungen erzeugt und vor allem eine an sich wirklich todsimple Sache völlig unnötig verkompliziert. Ich hoffe einfach mal inständig, das Beispiel stammt nicht von einem Lehrer oder Dozenten. Wenn ja, nimm es als Beispiel dafür wie man es nicht macht. Code sollte lesbar und bestenfalls selbsterklärend sein.

Sollte die Erhöhung um je eins so beabsichtigt sein, wär das die "Standard"lösung (a durch i qua Konvention ersetzt):

int n = 5;
for(int i = 3; i < n + 1; i++) {
     System.out.println(i - 1);
}

Erklärung:

1. n wird mit dem Wert 5 initialisiert
2. i wird mit dem Wert 3 initialisiert
3. Die Schleife läuft nun so lange wie i kleiner als n + 1 (also 6) ist.
4. i hingegen wird mit jedem Durchlauf um eins erhöht (i++, Inkrementierung)
5. Deshalb erhöht sich der Wert in der Ausgabe jede Runde um 1
6. n ändert sich nicht, deshalb wird der Abbruch durch die Erhöhung von i ausgelöst

Sollte beabsichtigt sein, dass i um je zwei erhöht wird, kannst du statt

i++

einfach

i+=2

schreiben. i bliebe dann ungerade und es würden nur die geraden Zahlen geprinted werden.

Die Initialisierung von i kann man auch außerhalb der Schleife vornehmen, wenn man davon ausgeht, dass der Wert schnell erkannt und von anderen Entwicklern angepasst werden kann. Ist aber eher unüblich, weil i meistens auf 0 gesetzt wird oder einen dynamischen Wert, der dann dekrementiert wird (i--), mit Abbruchbedingung i > n. Dann wäre die elegantere Lösung aber fast eine while Schleife :-)

int n = 5;
int a = 3;
while(a <= n) {
    System.out.println(a++ - 1);
}