Duvida sobre prova

y = y++ - a atribuição acontece antes do incremento.
y = ++y - a atribuição acontece depois do incremento.

no caso aí, primeiro “acontece” o y=y e depois o y++…
entendeu?

Oi,
acontece o seguinte,

quando passado isso:

int y = 0;
System.out.println(y = y++); // Resultado 0

ele está mostrando e depois calculando.

quando mostrado isso:

int y = 0;
System.out.println(y = ++y); // Resultado 1

Ele esta calculando e depois mostrando…

Mas acredito que y = y++ ou y = ++y está absurdamente errado, pois deveria ser somente: y++ ou ++y.

Tchauzin!

++ é um operador unário, ou seja, que só tem um operando.

Pode-se pensar que “y++” faz o mesmo trabalho que “y = y + 1”

O operador pode ser pré-fixado ou pós-fixado ao operando.

Quando pré-fixado (ex.: ++y), primeiro ocorrerá a soma (y+1) e depois será feita a leitura do valor resultante.
Quando pó-fixado (ex.: y++), primeiro ocorrerá a leitura de y e depois será feita a soma (y+1).

Pode-se pensar da seguinte forma:

//código equivalente a ++y (supondo que o valor de y passado ao método vai ser alterado, o que não acontece em java)
public int incrementoPreFixado(int y) {

   y = y + 1; //atualiza o valor de y.

   return y; //exibe o novo valor de y, depois do incremento.
}

//código equivalente a y++ 
public int incrementoPosFixado(int y) {
   int retorno = y; //guarda o valor de y, antes do incremento

   y = y + 1; //atualiza o valor de y.

   return retorno; //exibe o antigo valor de y, antes do incremento.
}

public static void main(String[] args) {
    int y = 0;

    SysoutincrementoPosFixado(y); //exibe 0 e muda o valor de y pra 1

    Sysout(incrementoPreFixado(y)); // exibe 2 e muda o valor de y pra 2
    
}

Claro que esses métodos só não funcionarão exatamente como os operadores pois não teria como alterar valor de y passado ao método, pois em Java não existe passagem de valores por referência, apenas por cópia.

Isso aí é válido porque y++ ou ++y são operações que retornam um valor e, por isso, podemos atribuir tal resultado a uma variável.

I

rissato:

y = y++ - a atribuição acontece antes do incremento.
y = ++y - a atribuição acontece depois do incremento.

no caso aí, primeiro “acontece” o y=y e depois o y++…

entendeu?</blockquote>

Isso que me falaste nao é nada de novo leia por favor de novo a minha mensagem!!

class A{

int y=0;

y=y++;

System.out.println(y);//resultado é Zero ao invez de "1"pois em c em varios outros compiladores é 1 essa. Essa é  a minha duvida e nao sobre o que é ++y ou y++ pré-incremento e pós-incremento

}

valeu!

rissato:

y = y++ - a atribuição acontece antes do incremento.
y = ++y - a atribuição acontece depois do incremento.

no caso aí, primeiro “acontece” o y=y e depois o y++…
entendeu?

Eu tbm não entendi.

primeiro acontece y=y

depois acontece y++

Logo se vc tivesse:

System.out.println(y=y++);
System.out.println(y);

deveria imprimir:
0
1

mas…não é o q ocorre?

pq? afinal de contas…depois acontece y++, então pq na segunda linha não imprimiu 1?

A atribuição é sempre a última operação a ser realizada… veja no passo a passo mais ou menos o q aconteceu:

int y = 0; //inicializou y com zero
y = y++;
/*

• primeiro, será feita a avaliação dos operandos, do lado direito temos uma operacao y++… qual o resultado dela? ZERO, pois o operador foi pos-fixado… entao, a JVM já sabe que o valor a ser atribuido eh ZERO.
• Em seguida, o valor de y é incrementado em 1 e o valor de y passa a ser 1.
• Mas, por fim, aquele valor que foi lido inicialmente (ZERO) será atribuido a y (por causa do operador de atribuição)
• Então, no final de tudo, nesse caso, o valor de y vai ser ZERO.
  */

Ou seja, se tivessemos apenas y++, o resultado de y seria 1, mas como tinhamos y = y++, entao o valor final eh zero.

se fosse usar a analogia dos metodos q eu fiz eh como se fizesse:

y = incrementoPosFixado(y); //após encerrar o método, temos que o retorno dele foi zero e o valor de y é 1… mas aih estamos pegando o resultado, que foi zero, e atribuindo a y, que passa a ser zero.

[]'s

RafaelVS:

++ é um operador unário, ou seja, que só tem um operando.

Pode-se pensar que “y++” faz o mesmo trabalho que “y = y + 1”

O operador pode ser pré-fixado ou pós-fixado ao operando.

Quando pré-fixado (ex.: ++y), primeiro ocorrerá a soma (y+1) e depois será feita a leitura do valor resultante.
Quando pó-fixado (ex.: y++), primeiro ocorrerá a leitura de y e depois será feita a soma (y+1).

Pode-se pensar da seguinte forma:

//código equivalente a ++y (supondo que o valor de y passado ao método vai ser alterado, o que não acontece em java)
public int incrementoPreFixado(int y) {

   y = y + 1; //atualiza o valor de y.

   return y; //exibe o novo valor de y, depois do incremento.
}

//código equivalente a y++ 
public int incrementoPosFixado(int y) {
   int retorno = y; //guarda o valor de y, antes do incremento

   y = y + 1; //atualiza o valor de y.

   return retorno; //exibe o antigo valor de y, antes do incremento.
}

public static void main(String[] args) {
    int y = 0;

    SysoutincrementoPosFixado(y); //exibe 0 e muda o valor de y pra 1

    Sysout(incrementoPreFixado(y)); // exibe 2 e muda o valor de y pra 2
    
}

Claro que esses métodos só não funcionarão exatamente como os operadores pois não teria como alterar valor de y passado ao método, pois em Java não existe passagem de valores por referência, apenas por cópia.

Isso aí é válido porque y++ ou ++y são operações que retornam um valor e, por isso, podemos atribuir tal resultado a uma variável.

Olha sinceramente acho que isso tem mais aver com o fato que o método vai ficar no heap ou algo assim e a variavel local na pilha, o compilador dever dar algun tipo de preferencia considerando o pós e o pré ,que eu nao sei

int y=0;

y =y++;

System.out.prinltn(y);resultado é zero mas ja em c e outros compiladores é  um

RafaelVS:

A atribuição é sempre a última operação a ser realizada… veja no passo a passo mais ou menos o q aconteceu:

int y = 0; //inicializou y com zero
y = y++;
/*

• primeiro, será feita a avaliação dos operandos, do lado direito temos uma operacao y++… qual o resultado dela? ZERO, pois o operador foi pos-fixado… entao, a JVM já sabe que o valor a ser atribuido eh ZERO.
• Em seguida, o valor de y é incrementado em 1 e o valor de y passa a ser 1.
• Mas, por fim, aquele valor que foi lido inicialmente (ZERO) será atribuido a y (por causa do operador de atribuição)
• Então, no final de tudo, nesse caso, o valor de y vai ser ZERO.
  */

Ou seja, se tivessemos apenas y++, o resultado de y seria 1, mas como tinhamos y = y++, entao o valor final eh zero.

se fosse usar a analogia dos metodos q eu fiz eh como se fizesse:

y = incrementoPosFixado(y); //após encerrar o método, temos que o retorno dele foi zero e o valor de y é 1… mas aih estamos pegando o resultado, que foi zero, e atribuindo a y, que passa a ser zero.

[]'s

hmmmm…

agora entendi! Eu acreditava que o pós-incremento era sempre a última coisa a acontecer num comando. Ainda acho que isso seria o mais lógico, mas enfim, pra ter sido feito assim era pq deveria ter sua necessidade…

valeu Rafael!

fabioEM:

Olha sinceramente acho que isso tem mais aver com o fato que o método vai ficar no heap ou algo assim e a variavel local na pilha, o compilador dever dar algun tipo de preferencia considerando o pós e o pré ,que eu nao sei

int y=0;

y =y++;

System.out.prinltn(y);resultado é zero mas ja em c e outros compiladores é  um</blockquote>

Essa explicação que eu dei não foi em relação ao resultado de y = y++… foi apenas explicando o que eh pre e pos incremento. A explicação sobre o que realmente acontece foi a que eu respondi em seguida:

RafaelVS:

A atribuição é sempre a última operação a ser realizada… veja no passo a passo mais ou menos o q aconteceu:

y = incrementoPosFixado(y); //após encerrar o método, temos que o retorno dele foi zero e o valor de y é 1… mas aih estamos pegando o resultado, que foi zero, e atribuindo a y, que passa a ser zero.

[]'s

Como o retorno é um valor e existe outro valor??

y = incrementoPosFixado(y); //após encerrar o método, temos que o retorno dele foi zero e o valor de y é 1…
essa parte nao entendi quantas variaveis tem entao 2,uma na pilha??e a outra?Mas as variaves locais nao ficam todas la?
e desde ja agradeço sua atencao!!

se vc olhar o corpo do método, perceberá que tem uma variavel “retorno” que guarda o valor a ser retornado.

quote=RafaelVS]A atribuição é sempre a última operação a ser realizada… veja no passo a passo mais ou menos o q aconteceu:

y = incrementoPosFixado(y); //após encerrar o método, temos que o retorno dele foi zero e o valor de y é 1… mas aih estamos pegando o resultado, que foi zero, e atribuindo a y, que passa a ser zero.

[]'s[/quote]

[/quote]

Tudo bem mas me tira outra duvida
y++ é igual a y=y+1
System.out.println(y);//imprime 1;ok!!

entao por essa logica
y=y++ é igual y=y=y+1
deveria imprimir 0 ok?,mas…

class A{

public static void main(String a[]){

int y=0,a=0;

y=y++;

System.out.println(y);//tenho um resultado que é zero

//se fizer

a=a=a+1;

System.out.println(a);//tenho 1 outro resultado!!

Como fica??

}

}

veja…

quando vc usa y++ vc ta usando um operador unário pós-fixado… ele tem um funcionamento especial… como é esse funcionamento? primeiro lê-se o valor inicial do operando (que será o valor da expressão) e depois incrementa seu valor… o significado é: “incremente o valor de y e mas retorne o valor antigo dele”

quando vc usa a = a + 1, vc nao está usando um operador unário… não tem nenhum funcionamento especial aqui… então o que acontece? eu estou somando o valor de a, em seguida estou atribuindo esse valor a a… o operador “atribuição” também retorna um valor… e o valor que ele retorna é igual ao valor que foi atribuido. Assim sendo, como a + 1 retornou 1, então o valor da atribuição é 1.

Ou seja, se vc manda exibir y++, será exibido 0… se vc manda exibir a = a + 1, será exibido 1. Assim sendo, não será diferente se tentarmos atribuir essese valores a uma variável. Então, temos que:

y = y++; // valor final de y = 0
a = a = a + 1; // valor final de a = 1

0 e 0

como assim o seria se fizesse:

int y = 0;

y = y++;

y = y++;

y = y++;

y = y++;

y = y++;

y = y++;

/…

y = y++;

y = y++;

y = y++;

y = y++;

y = y++;

y = y++;

sysout(y); // exibe 0

agora x eh 0 e y eh 1, ja que o valor de y na segunda operacao nao foi atribuido a y.

agora faz esse aqui, sem testar tb:

int x, y = 0;

y = y++;

x = x++;

x = y;

sysout(x);
sysout(y);

0,0 em java.
então, eu li que cada compilador trata do pos incremento de uma maneira diferente, ou seja, o resultado varia de compilador pra compilador.
testei em g++ o resultado foi outro.

formigaotts:

0,0 em java.
então, eu li que cada compilador trata do pos incremento de uma maneira diferente, ou seja, o resultado varia de compilador pra compilador.
testei em g++ o resultado foi outro.

Errado…

em Java isso vai dar erro de compilação, pois a variável x está tentando ser acessada sem antes ter sido inicializada:

int x, y=0;

hehehhehehe (é esse tipo de pegadinha que lasca o cara na prova da certificação)

RafaelVS:

0 e 0

como assim o seria se fizesse:

int y = 0;

y = y++;

y = y++;

y = y++;

y = y++;

y = y++;

y = y++;

/…

y = y++;

y = y++;

y = y++;

y = y++;

y = y++;

y = y++;

sysout(y); // exibe 0

entao vc tbm errou aqui pq sysout(y); da erro! =)

por isso desconsiderei aquele y,x = 0;

mas aí eu nao disse que era java… eu tava usando uma pseudo-linguagem, como fiz em todos os outros exemplos.

ja vc… respondeu que “em java, o resultado seria 0,0” =/

além disso, eu mesmo escrevi o primeiro codigo… sysout esta ali por preguica minha… ou se preferir isso aih podia ser apenas um trecho do codigo… onde sysout eh um metodo da classe (que usa System.out.println) que escrevi e que nao coloquei no exemplo =/

já a sua resposta, foi q vc caiu na pegadinha mesmo hehehe e n tem metodo que mude o erro de compilacao.

Sou iniciante JR !
Mas vejam se eu entendi a coisa.

y = y++ // y++ retorna y e soma 1 a y, então (y + 1) recebe y que é o retorno de y++ pois “A atribuição é sempre a última operação a ser realizada.” É ISSO??? :roll:

[quote=RafaelVS]veja…

Ou seja, se vc manda exibir y++, será exibido 0… se vc manda exibir a = a + 1, será exibido 1. Assim sendo, não será diferente se tentarmos atribuir essese valores a uma variável. Então, temos que:

pois é qd mando imprimir y++ vai ser 1 e nao zero!!,se mandar exibir y=y+1;vai ser 1 novamente

int a=0,y=0;

y=y+1;

a++;

System.out.println(y);

System.out.println(a);

mas nesse codigo vc nao exibiu a++… vc exibiu o valor de a após a operação a++

exibir a++ quer dizer:

sysout(a++);

mas o que vc fez foi

a++; // depois dessa linha o valor de a é 1. por isso embaixo exibe 1.

sysout(a);

lina:

Oi,
acontece o seguinte,

quando passado isso:

int y = 0;
System.out.println(y = y++); // Resultado 0

ele está mostrando e depois calculando.

quando mostrado isso:

int y = 0;
System.out.println(y = ++y); // Resultado 1

Ele esta calculando e depois mostrando…

Mas acredito que y = y++ ou y = ++y está absurdamente errado, pois deveria ser somente: y++ ou ++y.

Tchauzin!

fabioEM:

RafaelVS:

veja…

Ou seja, se vc manda exibir y++, será exibido 0… se vc manda exibir a = a + 1, será exibido 1. Assim sendo, não será diferente se tentarmos atribuir essese valores a uma variável. Então, temos que:

pois é qd mando imprimir y++ vai ser 1 e nao zero!!,se mandar exibir y=y+1;vai ser 1 novamente

int a=0,y=0;

y=y+1;

a++;

System.out.println(y);

System.out.println(a);

</blockquote></blockquote>

Desculpem, não quero parecer arrogante, mas o negocio parece ser simples de entender!
a++//retorna a e incrementa a
++a//retorna a + 1 e incrementa a

No caso acima System.out.println(a);//utiliza “a” que foi incrementado e descarta o valor de a++(0) uma vez que ele não foi guardado por nenhuma variavel.

eh simples mesmo… mas se n entenderam, tive que explicar com detalhes hehe

nem tudo que ta nesse quote aih foi eu que escrevi (o cara nao soube “quotar” direito)

mdea:

fabioEM:

RafaelVS:

veja…

Ou seja, se vc manda exibir y++, será exibido 0… se vc manda exibir a = a + 1, será exibido 1. Assim sendo, não será diferente se tentarmos atribuir essese valores a uma variável. Então, temos que:

pois é qd mando imprimir y++ vai ser 1 e nao zero!!,se mandar exibir y=y+1;vai ser 1 novamente

int a=0,y=0;

y=y+1;

a++;

System.out.println(y);

System.out.println(a);

</blockquote></blockquote>

Desculpem, não quero parecer arrogante, mas o negocio parece ser simples de entender!
a++//retorna a e incrementa a
++a//retorna a + 1 e incrementa a

No caso acima System.out.println(a);//utiliza “a” que foi incrementado e descarta o valor de a++(0) uma vez que ele não foi guardado por nenhuma variavel.

Bom a meu ver vc acabou sendo um pouco arrogante sim.Mas tudo bem,nao é um pecado capital… me explique antao o do pq deste bizarro acontecimento:
2 expressoes matemáticas escritas de forma diferente mas com o mesmo operador unário Pós incremento em ambas , valores inicias para os tipo primitivo iguais

int b,a =1;

b=1;

a = a + a++; //resultado 2

b = b++ + b; //resultado 3

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

opss…lascou nao é???

Cara, esse não é o primeiro tópico onde vejo você criticando o pessoal que está apenas tentando te ajudar. Acretido que o mdea foi humilde demais, inclusive, no comentário que ele fez pq essa sua dúvida é coisa muito básica.

Bote na sua cabeça que Java não é C. Se as coisas estão acontecendo, então há alguma explicação para tal (pelo menos em 99,99% dos casos… e esse é um deles).

Com o pouco conhecimento que vc tem em Java, você não vai conseguir achar um “furo” assim tão facilmente.

Dito isso, responderei (pela última vez) à sua pergunta (ou qualquer outro comentário que vc venha a fazer aqui e em outros tópicos):

Quando avaliamos uma expressão que contém vários operadores, primeiramente são avaliados os operandos e em seguida os valores de cada operador individualmente (seguindo uma ordem definida pela linguagem).

Em Java, um dos operadores de maior precedênca é o unário. Assim sendo, ele tem prioridade ao operador binario de soma.

int b, a = 1;

b = 1;

a = a + a++; //linha1: resultado 2

b = b++ + b; //linha2: resultado 3

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

Nesse código, o que está acontecendo?

Imagine que as linhas 1 e 2 tenham o seguinte formato:
X = Y + Z

Para eu saber o resultado dessa operação, preciso avaliar os valores de Y e de Z.

Na linha1, temos que Y é a (que vai ser 1) e Z é a++(que vai retornar 1 e incrementar o valor de a). Então, temos:
X = Y + Z => X = a + a++ => X = 1 + 1 => X = 2 (por sinal, X é a, então: a = 2)

Na linha2, temos que Y é b++ (que retorna 1 e JÁ INCREMENTA O VALOR DE B para 2) e Z é b (que nesse momento já vale 2). Então, temos:
X = Y + Z => X = b++ + b => X = 1 + 2 => X = 3 (por sinal, X é b, então: b = 3)

Finalizando o código, a linha System.out.println(a+"-"+b); exibirá: 2-3

Ou seja, o que tá lascando aqui, na verdade, é essa confusão que você está fazendo entre Java e C e a sua forma de tratar o pessoal que está aqui tentando te ajudar.

Continue tentando. (Mas daí para eu te desejar sucesso, já seria hipocrisia).

Fui.

Obs.: Não perca seu tempo deixando comentários dirigidos a mim, pois, como já disse antes, essa foi a última vez que me dirigi a você (só espero que você mude seu jeito, pois ter alguém assim por aí não é bom para ninguém).

opss erro

RafaelVS:

fabioEM:

Bom a meu ver vc acabou sendo um pouco arrogante sim.Mas tudo bem,nao é um pecado capital… me explique antao o do pq deste bizarro acontecimento:
2 expressoes matemáticas escritas de forma diferente mas com o mesmo operador unário Pós incremento em ambas , valores inicias para os tipo primitivo iguais

int b,a =1;

b=1;

a = a + a++; //resultado 2

b = b++ + b; //resultado 3

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

opss…lascou nao é???

Cara, esse não é o primeiro tópico onde vejo você criticando o pessoal que está apenas tentando te ajudar. Acretido que o mdea foi humilde demais, inclusive, no comentário que ele fez pq essa sua dúvida é coisa muito básica.

Bote na sua cabeça que Java não é C. Se as coisas estão acontecendo, então há alguma explicação para tal (pelo menos em 99,99% dos casos… e esse é um deles).

Com o pouco conhecimento que vc tem em Java, você não vai conseguir achar um “furo” assim tão facilmente.

Dito isso, responderei (pela última vez) à sua pergunta (ou qualquer outro comentário que vc venha a fazer aqui e em outros tópicos):

Quando avaliamos uma expressão que contém vários operadores, primeiramente são avaliados os operandos e em seguida os valores de cada operador individualmente (seguindo uma ordem definida pela linguagem).

Em Java, um dos operadores de maior precedênca é o unário. Assim sendo, ele tem prioridade ao operador binario de soma.

int b, a = 1;

b = 1;

a = a + a++; //linha1: resultado 2

b = b++ + b; //linha2: resultado 3

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

Nesse código, o que está acontecendo?

Imagine que as linhas 1 e 2 tenham o seguinte formato:
X = Y + Z

Para eu saber o resultado dessa operação, preciso avaliar os valores de Y e de Z.

Na linha1, temos que Y é a (que vai ser 1) e Z é a++(que vai retornar 1 e incrementar o valor de a). Então, temos:
X = Y + Z => X = a + a++ => X = 1 + 1 => X = 2 (por sinal, X é a, então: a = 2)

Na linha2, temos que Y é b++ (que retorna 1 e JÁ INCREMENTA O VALOR DE B para 2) e Z é b (que nesse momento já vale 2). Então, temos:
X = Y + Z => X = b++ + b => X = 1 + 2 => X = 3 (por sinal, X é b, então: b = 3)

Finalizando o código, a linha System.out.println(a+"-"+b); exibirá: 2-3

Ou seja, o que tá lascando aqui, na verdade, é essa confusão que você está fazendo entre Java e C e a sua forma de tratar o pessoal que está aqui tentando te ajudar.

Continue tentando. (Mas daí para eu te desejar sucesso, já seria hipocrisia).

Fui.

Obs.: Não perca seu tempo deixando comentários dirigidos a mim, pois, como já disse antes, essa foi a última vez que me dirigi a você (só espero que você mude seu jeito, pois ter alguém assim por aí não é bom para ninguém).

Bom meu amigo em primeiro plano, tome um chásinho que é bom,respire fundo e leia com calma o que esta escrito a partir de agora.
Caso nao consiga va para sexta-feira na sessao do descarrego na igreja
Universal mais proxima!!
1)Nunca quis encontrar furos na linguagem java, primeiro pq gosto e segundo a considero muito eficiente
2)Nao estou aqui para criticar ninguém, defato ate o momento achei que sua resposta nao chegasse a uma solucao para todos os casos!
3)Bote vc uma coisa na sua cabeca pequena, com essa ARROGANCIA nao se chega a lugar algum.

E agora vou te mostrar como VC CONTINUA SEM SABER SOLUCIONAR O PROBLEMA EM QUESTAO

se vc tem uma expressao

a=0;

a=a++ + a++;

entao pela tua incrivel logica e pelo teu super altissimo elevadissimo nivel de conhecimento  vc deveria  saber pq o resultado dessa espressao é 1

eu ja encontrei a resposta e nao tem nada a ver com toda essa tua louca explicao que eu chamaria de ENROLATION!

Na verdade meu amigo mestre em java,  TODA expressao matematica é representada atráves de arvores mas nao aquelas que vc pensa ,ok?

Em segundo lugar, existem caminhos para percorrer esta arvore devido ao fato de ouver preferencias nas vária operecoes…Não gastar muito tempo

Para  expressoes com operadores  unários o compilador  cria uma arvore e a percorre de maneira In_order ,para o pós incremento, o percurso é entao Pré_order.

Me diz agora,se sabes tanto? Qual foi a faculdade que te formates ?pois este assunto é de 2 semestre meu amigo e nao precisa  ter um certificado para responder tal questao ou chamarse Rafael

Dito isso reflita comigo  SERA QUE REALMENTE MEU CONHECIMENTO É TAO GRANDE  ?Vc me lembra a historia da formiguinha,nao vou demorar.

Certa  vez uma formighinha  ao voltar para o formigueiro esbarrou-se no meio de uma montanha composta por  cristais de acucar,com a maior felicidade to mundo  recolheu um cristal e foi esbanjar para todas as outras formighinhas  como ela é corajosa e sagaz,no entanto

o resto do acucar ficou lá, pois para aquela simples formiguinha foi o suficiente.MORAL DA HISTORIA O VERDADEIRO SABIO É AQUELE QUE TEM CONHECIMENTO DE QUANTO ELE REALMENTE NAO  SABE

Pense bem entao antes de falar besteira,respire sempre fundo e analize quem vc é.

Para min ninguém…

fabioEM:

mdea:

fabioEM:

RafaelVS:

veja…

Ou seja, se vc manda exibir y++, será exibido 0… se vc manda exibir a = a + 1, será exibido 1. Assim sendo, não será diferente se tentarmos atribuir essese valores a uma variável. Então, temos que:

pois é qd mando imprimir y++ vai ser 1 e nao zero!!,se mandar exibir y=y+1;vai ser 1 novamente

int a=0,y=0;

y=y+1;

a++;

System.out.println(y);

System.out.println(a);

</blockquote></blockquote>

Desculpem, não quero parecer arrogante, mas o negocio parece ser simples de entender!
a++//retorna a e incrementa a
++a//retorna a + 1 e incrementa a

No caso acima System.out.println(a);//utiliza “a” que foi incrementado e descarta o valor de a++(0) uma vez que ele não foi guardado por nenhuma variavel.

Bom a meu ver vc acabou sendo um pouco arrogante sim.Mas tudo bem,nao é um pecado capital… me explique antao o do pq deste bizarro acontecimento:
2 expressoes matemáticas escritas de forma diferente mas com o mesmo operador unário Pós incremento em ambas , valores inicias para os tipo primitivo iguais

int b,a =1;

b=1;

a = a + a++; //resultado 2

b = b++ + b; //resultado 3

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

opss…lascou nao é???

Bom Fabio, acho que sou tão iniciante quanto vc e infelizmente não sou um genio, tenho que ralar(ler e reler) para poder entender e prosseguir no aprendizado desta linguagem que tanto gosto; bom o rafael disse tudo e o que me resta dizer é, ESTUDA CARA, ESTUDA ESTUDA E ESTUDA, somente assim poderemos discutir de forma civilizada e construtiva; e tambem compartilhar o conhecimento adiquirido sem duvida com muito esforço por todos nós, de qualquer forma, boa sorte!

a=0;
a=a++ + a++;

1 - “a++” retorna 0 e incrementa “a” então “a” == 1
2 - “a++” retorna 1 que é o valor de “a” incrementado e passa a valer 2
3 - “0 + 1” == 1
4 - a atribuição é feita e então “a” == 1

mas vc já sabia, é claro!
cara eu lamento se fui arrogante a principio, não foi minha intenção, mas numa boa, vou me retirar deste tópico que poderia ser melhor aproveitado, mas

formigaotts:

pra concluir entao, sem testar, qual é o resultado dos sysouts?

int x, y = 0;
			
y = y++;
y = y++;
x = y;
System.out.println(x);
System.out.println(y);

0 e 0

formigaotts:

pra concluir entao, sem testar, qual é o resultado dos sysouts?

int x, y = 0;
			
y = y++;
y = y++;
x = y;
System.out.println(x);
System.out.println(y);

0 e 0

rissato:

y = y++ - a atribuição acontece antes do incremento.
y = ++y - a atribuição acontece depois do incremento.

no caso aí, primeiro “acontece” o y=y e depois o y++…
entendeu?

me expressei mal, pra o que eu queria dizer o certo é:
x = y++
x = ++y

Pelo menos esse erro gerou uma discussãozinha legal…