Inkrementacja zmiennej w deklaracji pętli a w ciele

public class Sample {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            System.out.println("Hej");
        }
    }
}

Zachowanie takiej pętli znam, ale chyba nie do końca jak to działa pod spodem, ponieważ kombinowałem sobie zrobić taki kodzik:

public class Sample2 {
    public static void main(String[] args) {
        for (int i = 0; i < 10; ) {
            i = i++;
            System.out.println("Hej2");
        }
    }
}

I ten kod spowoduje, że pętla będzie nieskończona. I teraz zastanawia mnie czym się różni i++ wewnątrz ciała a deklaracja i++ wewnątrz deklaracji pętli?

Jeszcze zrobiłem sobie trzeci przypadek:

public class Sample3 {
    public static void main(String[] args) {
        for (int i = 0; i < 10; ) {
            i++;
            System.out.println("Hello");
        }
    }
}

Teraz zadziała to tak jak w przypadku numer 1. To co się dzieje z i++ w drugim przypadku. Gdzieś to w ogóle jest wykonywane to zwiększenie?

Czy po prostu mam zapamiętać, że co innego np. zrobić samo i++ w pętli czy nawet je wypisać println(). A co innego zrobić przypisanie do zmiennej.

Tylko skoro operujemy na tej samej zmiennej to czy mimo wszystko nie powinna ona zostać zwiększona o jeden?

Znalazłem taki przykład na stackoverflowe:

int i = 0;
System.out.print(i++);
System.out.print(i);

Wydrukowane zostanie: 01 to przenosząc to na mój kod powyżej i robiąc tak:
Jeszcze zrobiłem sobie trzeci przypadek:

public class Sample3 {
    public static void main(String[] args) {
        for (int i = 0; i < 10; ) {
            i = i++;
           System.out.print(i); //Będzie cały czas 0
            System.out.println("Hello");
        }
    }
}

P. S Mam nadzieję, że nie pominąłem jakiś ważnych linijek kodu ;p

Kompilatory czasem i tak generują kod po swojemu, a użycie optymalizacji generuje kod za pewne dążący do podobnych schematów, jakościowych przez określone algorytmy.

Odpowiedź jest bardzo prosta. Jeśli masz linijkę i++; oznacza to, że najpierw chcesz zobaczyć zmienną i, a potem ją inkrementować. Linijka i = i++ jest bardzo głupia, ponieważ mówi kompilatorowi w ten sposób:

1. Weź wartość zmiennej i i zapamiętaj
2. dodaj 1 do zmiennej i
3. Przypisz wartość z punktu 1) do zmiennej i

Wskutek tego cały czas jest ta sama wartość.

EDIT: i++ to skrót po prostu od i = i+1

@D3X twoje pytanie jest trochę bez sensu. Przecież przypisujesz nową wartosć do zmiennej więc czemu sie dziwisz?

i = i++;

rozwija się do:

tmp = i;
i = i+1;
i = tmp;

Jak widzisz są tam dwa przypisania do zmiennej i i to drugie przywraca początkową wartość.

http://www.coderanch.com/t/659942/Wiki/Post-Increment-Operator-Assignment
http://stackoverflow.com/questions/7911776/what-is-x-after-x-x

@Shalom
No może dla Ciebie wydaję się trochę bez sensu.

Ale dzięki za rozpisanie. Czyli jest to kolejna rzecz, która działa tak, a nie inaczej i tyle. Bo bez sensu jest trochę takie działanie:

tmp = i;
i = i+1;
i = tmp;

@D3X oczywiście że jest bez sensu, ale to jest TWÓJ kod. Sama postinkrementacja to coś w stylu:

int operator++(int& x){
    int tmp = x;
    x = x +1;
    return tmp;
}

I to działa dość sensownie. To ty po prostu zrobiłeś jakieś dzikie przypisanie. To tak jakbyś napisal:

x = x+10;
x = x-1;

I narzekał nam że zamiast zwiększyć wartość x o 10 to ci sie zwiększa tylko o 9 ;]