Certificação - essa é dificil

Isto ocorre porque a ordem de uma avaliação associativa é da direita para esquerda, e a ordem de uma avaliação de expressao é feito da esquerda para direita.

Lembrando também que em uma expressão os operadores (++,–) são feitos antes do operadores binarios (+,-,*,/,%,etc…).

Então,

a = a++; (avaliação associativa, resultado a = 1)
b = b++ + b; (avalia a expressão, sendo primeiro feito o incremento, depois a soma e então associa a b, resultado b = 3,)

Caso queira saber mais, procure pelo assunto Operadore Unarios, Binarios e Ordem de Avalição dos operandos em JAVA.

Qualquer duvida é só postar…

lembrando que…

a = a++; --> é um pós-incremento se fosse a = ++a; o resultado seria 2.

Qual seria o resultado se fizermos a seguinte modificação:

public class testeCodigoEstanho {

public static void main(String[] args) {

int a =1;
int b =1;

a = ++a;
b = ++b + b;

System.out.println(a+" - "+b);

}

}

Dica: faça passo-a-passo e desmembre a expressão.

dai seria 2 - 4
mas eu continuo sem entender…

Fala Max, beleza? Acho que posso ajudar.

“maxguzenski”:

dai seria 2 - 4
mas eu continuo sem entender… :(

a = ++a;

b = ++b + b;

System.out.println(a+" - "+b);

Nesse caso acima, no primeiro statement, ‘a’ assume valor 2. No segundo statement ++b por ser unary e prefixado, possue maior precedência que o operador +, assim é executado primeiro (é incrementado em 1). Dessa forma, b passa a ser 2. Só aí, b é somado a ele mesmo, resultando em 4.

No último statetement, como o operador - está entre aspas, é considerado uma String assim, println concatena toda a expressão como sendo uma String, resultando em “2 - 4”, que é então imprimido.

Espero ter ajudado,

“maxguzenski”:

dai seria 2 - 4
mas eu continuo sem entender… :(

Experimente analisar linha por linha:

essa é a classe original:

public class testeCodigoEstanho {

public static void main(String[] args) {

int a =1; (a recebe 1)
int b =1; (b recebe 1)

a = a++;

• a recebe +1 na próxima vez que for referenciado, por enquanto vale 1
• a recebe 1

b = b++ + b;

• b recebe +1 na próxima vez que for referenciado, por enquanto vale 1
• b recebe b+b, ou seja, 1 + 1

System.out.println(a+" - "+b);

}

}

Melhorou agora ?

Só uma pequena correção ao que foi dito pelo nosso amigo acima:

public class testeCodigoEstanho {

public static void main(String[] args) {

int a =1; // a = 1
int b =1; // b = 1

a = a++; // a++ ainda é igual a 1, se fosse novamente referenciado
// passaria a ser 2, mas a foi igualado a 1. Entendeu isso?

b = b++ + b;
// b++ ainda é igual a 1, quando for novamente referenciado será 2
// portanto o segundo b da expressão é 2, assim sendo: b = 1 + 2 = 3

System.out.println(a+" - "+b);

}

}

:roll: Êta!!!

Epa!
Eu mesmo não segui a lógica da minha própria explicação :!:

O correto seria:

b = b++ + b;

• b recebe +1 na próxima vez que for referenciado, por enquanto vale 1
• b recebe b(antigo=1)+b(novo=b+1), ou seja, 1 + 2

O interpretador Java segue uma ordem na execução de operadores…

a++ é diferente de ++a;

e durante a avaliação da expressão… ++a (pré-incremento) é executado antes de qualquer associação e a++ (pós-incremento) é executado depois de todas as associações…

bom estudo…

opss erro

ops erro 2

hivaj:

Isto ocorre porque a ordem de uma avaliação associativa é

b = b++ + b; (avalia a expressão, sendo primeiro feito o incremento, depois a soma e então associa a b, resultado b = 3,)

Caso queira saber mais, procure pelo assunto Operadore Unarios, Binarios e Ordem de Avalição dos operandos em JAVA.

Qualquer duvida é só postar…

fabio,

o código abaixo é executado na seguinte sequencia:

b = b++ + b // código original
b = 1 + b // substituição do primeiro ‘b’ pelo seu valor (1), e é feito o incremento (b passa a valer 2)
b = 1 + 2 // substituição do segundo ‘b’ pelo seu valor (2).
b = 3 // b recebe o valor da soma (3)

Conforme você citou, como ficaria se fosse assim:

b = b++ + b++ // seu código
b = 1 + b // substituição do primeiro ‘b’ pelo seu valor (1), e é feito o incremento (b passa a valer 2)
b = 1 + 2 // substituição do segundo ‘b’ pelo seu valor (2), e é feito o incremento (b passa a valer 3)
b = 3 // apesar de ‘b’ já possuir o valor de 3, ele recebe o resultado da soma (3)

se a expressão fosse:

b = b++ + b++ + b
o resultado seria 6

bom para mim o resultado ai seria 2 - 3 se tivesse essa opção ia marcar ela veja a explicao no codigo abaixo de maneira informal.

a = a++;
b = b++ + b;
 System.out.println(a+" - "+b);

//entao vc tem:
a = 1
agora [b]a [/b]vale 2.
b = 1 +(aqui B vale 2 devido ao pos-incremento) 2; resulta 1+2 = 3.
System.out.println(2+" - "+3);

flw!

LPJava:

bom para mim o resultado ai seria 2 - 3 se tivesse essa opção ia marcar ela veja a explicao no codigo abaixo de maneira informal.

a = a++;
b = b++ + b;
 System.out.println(a+" - "+b);

//entao vc tem:
a = 1
agora [b]a [/b]vale 2.
b = 1 +(aqui B vale 2 devido ao pos-incremento) 2; resulta 1+2 = 3.
System.out.println(2+" - "+3);

flw!

Camilo,
Creio eu que esteja errado …
a impressão seria: 1 - 3
Pois o código a = a++ anula o incremento quando não tem mais nenhuma operação como b = b++ + b;
É punk … mais uma pra ficarmos ligados na certificação …
Pensei que certificação seria como Nescau ou Toddy …

enfim o difícil não é analisar
b = b++ + b;

e sim perceber…

a = 1;

a = a++;



… continua valendo 1 …

puts dessa nao sabia que dizer que a é anulado na linha do pos incremento? pq?

O próprio ‘a’ já está sendo incrementado, então por que a ele mesmo atribuí-lo? (minha explicação, não tenho explicação técnica)
O interessante é que, se você colocar apenas a++, a impressão será 2.
Se continuar duvidando, faça o teste.
Eu até agora e “sempre” continuarei a duvidar … risos …
Engraçado. Não?
Esse exemplo não tem no livro da Kathy, mas se encontra no livro do Roberto Rubinstein …
Tá aí … algo que o livro não trouxe (pelo menos eu não vi no capítulo sobre atribuições)… :evil: :evil:
Tem algo a mais que alguém não viu no livro???

é eu tenho esse livro… vou dar uma olhada nesse capitulo e ter mais atenção nisso ai… puts foda questao assim… vou implementar aqui para ver… :D… valeu!!

O próprio ‘a’ já está sendo incrementado, então por que a ele mesmo atribuí-lo? (minha explicação, não tenho explicação técnica)
O interessante é que, se você colocar apenas a++, a impressão será 2.
Se continuar duvidando, faça o teste.
Eu até agora e “sempre” continuarei a duvidar … risos …
Engraçado. Não?
Esse exemplo não tem no livro da Kathy, mas se encontra no livro do Roberto Rubinstein …
Tá aí … algo que o livro não trouxe (pelo menos eu não vi no capítulo sobre atribuições)… :evil: :evil:
Tem algo a mais que alguém não viu no livro???

engraçado é que se tu fizer esse comando em C:

int a = 0;
a = a++;

a resposta é 1… ao contrário do java em que a resposta é 0.

pesquisando mais sobre o assunto …
http://www.guj.com.br/posts/list/69199.java

é rpz implementei aqui e deu 0… maior confusao isso

public class DuviA {

	
	public static void main(String[] args) {
		int y=0;
		y=y++;
		System.out.println(y);

	}

}

LPJava:

é rpz implementei aqui e deu 0.. maior confusao isso :(

public class DuviA {

	
	public static void main(String[] args) {
		int y=0;
		y=y++;
		System.out.println(y);

	}

}

LP, isso acontece pq a atribuição é a última coisa a acontecer. (procure na net ou em algum livro uma tabela com a precedência dos operadores).

a linha y = y++ significa atribuia a y o valor de y++... o resultado de y++ é "retorne 0 e incremente y para 1"... depois que y++ executou, o valor de y é 1 e o valor a ser atribuído a y é 0. Em seguida, a atribuição é executada e o valor de y passa a ser 0;

se fosse x = y++ o resultado seria x = 0 e y = 1... mas como ao invés do x temos o y, então o valor final de y é 0...

Deu pra sacar?

Abraços.

Resultado b é 0

int a = 0;
int b = a++; // o pos incremento só ocorre quando o 'a' for referenciado novamente.// 'b' é uma cópia de 'a', 
// como 'a' não foi referenciado até o final da instrução, 'b' é igual a 0
System.out.println(b);

Resultado b é 1

int a = 0;
int b = a++ + a; // como uma nova referencia é feita pra 'a'
// o incremento de a é realizado no término da operação e atribuído a 'b'.
System.out.println(b);

Resultado b é 0

int a = 0;
int b = a + a++; // como o pos incremento é realizado depois da ultima referencia pra 'a', 
// o incremento só irá ocorrer em uma nova referencia. 
// neste caso 0 + 0 = 0 
System.out.println(b);

Blz? :thumbup:

é conseguir entender… eu que fiz confusao em copo d’agua huauha… depois fui pensando nisso qdo ia para casa… e vi realmente… que nao tem pq ser outro valor:

int a=0;
int c= a++;

nao tem pq c ser 1… eu que me confudir… mais valeu ai pelas dicas… e parabens ao cidadao que abriu esse topico… boa !