Me ajudem. Estou com uma grande dúvida

Vamos aos comentários ehehe … vou falar o que sei, já meio que estudando, então podem me corrigir se disser besteira.
Ah, recomendo procurar no forum tb porque tem mais topicos sobre incrementos.

Não deveria. O pós-incremento só é executado depois das atribuições. Então o Java faz a seguinte operação para o exemplo 1:

a=a;

a++;

- Comente os exemplos: 3) e 4)
3) a=a++ +a; resposta será 3
4) a=++a +a; resposta será 4

Quebrando o 3 fica assim:
a = a; //1
a = a + a; //2
a++; //3

O 4 fica assim:
a++; //2
a = a + a //4

Entendeu? Pos-incremento feito depois de tudo, pré-incremento feito antes de tudo.

- Comente os exemplos: 5) e 6) - Por que independente da posição do incremento as respostas são as mesmas?
5) for(a=1; a<2; ++a) resposta será 1
6) for(a=1; a<2; a++) resposta será 1

Não sei … eu achei que sabia ehehe, mas pelo que sei em C esses laços sairiam com a=2 … pq ele faz o incremento, atribui e depois testa, a=2 ele sai mas não volta o valor de a pra 1 (antes do incremento) … alguem?

[]s

Camila, dá uma olhada no tópico abaixo, que esse assunto está bem discutido:

http://www.guj.com.br/forum/viewtopic.php?t=2853

resposta para o 5 e 6
é que em java, o incremento do for é executado sempre apos o loop, não importando se ele é utilizado pré ou pós incremento
ja no C, no loop ele tem comportamento diferente

eu costumo pensar da seguinte maneira para pré e pos incremento:

int a = 1;

int b = 0;

int c = 0;

b = ++a; // b = 2 e a =2;
c = a++; // c = 2 e a =3;

abrindo o codigo

b=++a ; equivale a:  a += 1;

b = a;

c=a++ ; equivale a: c = a;
a += 1;

Não sei se deu para entender, espero ter ajudado

deixa eu corrigir uma coisa para ficar mais claro.

int a = 1;

int b = 0;

int c = 0;

b = ++a; // b = 2 e a =2;
c = a++; // c = 2 e a =3;

abrindo o codigo:

b=++a ;

equivale

a: a += 1;
b = a;

e

c=a++ ;
equivale a:

c = a;
a += 1;

Deu pra entender legal o que você escreveu.
Veja se eu estou certa.

int a=1;
int b=0;

b=a++ + ++a; // b ficará 4

Mas quanto ao:
for(a=1; a<2; a++) ou
for(a=1; a<2; ++a) não deu pra entender. Quando será contado mais 1 na variável a?

neste caso, acho que não faz diferença de quando eles são incrementados.
pois:

for (<declaracao>, <expressao booleana>, <linha_executada_no_final>) {

<corpo>

}

a <linha_executada_no_final> pode ser a++ ou ++a.
Somente depois que o for executar todo o seu corpo, ele irá incrementar o a.

se o incremento fosse na <expressao booleana>, aí sim iria fazer diferença.

public class PrePosIncremento {

public static void main(String[] args) {
	int a=1;
	int b=0;

	b=a++ + ++a; // b ficará 4
	
	for(a=1; a++<2; a++) 
		System.out.println("Primeiro for: " + a);
		
	System.out.println("Depois do Primeiro for: " + a);
	
	for(a=1; ++a<2; ++a) 
		System.out.println("Segundo for: " + a); // esta linha não será executada
		
	System.out.println("Depois do Segundo for: " + a);
}

}

[/b]

Existe uma forma simples de saber o porque de

int x = 1;
x = x++;
System.out.println( x ) ;

imprime 1 ao invéz de 2.
Vamos quebrar em instruções de máquina :
Considere que 'i' está mapeada em  EES[ EBX ]

mov ax , EES[ EBX ]; salva o valor de 'i' em um acumulador.
mov di  , ax            ; instrução de incrementação
inc   di                    ; ...
mov EES[ EBX ] , di ; finaliza incrementação
mov EES[ EBX ] , ax; move o valor do acumulador para 'i' , perdendo 
                             ; o incremento.

agora pré-incremento :

mov ax , EES[ EBX ]; salva o valor de 'i' em um acumulador.
inc   ax                   ; ...
mov EES[ EBX ] , ax; finaliza incrementação
mov EES[ EBX ] , ax; move o valor do acumulador para 'i' , neste caso 
                             ; essa instrução é inútil ( side-efect do compilador )

Claudio Gualberto