Mais uma

Bem axo q tem um erro quando se tenta incrementar uma variável de instancia. No caso penso no erro quando é feito o ++x.b

fora isso acho q ta tudo correto.

5 e 9?

vou de 5 e 8…

Acho que 5 e 8 tambem, por que variaveis em contexto estatico mantem o mesmo valor pra instancias também. Na verdade a instancia não possui aquele valor e sim a classe.

Valor de b: 5
Valores: 8

Bom os valores terem sequencia é em função da variável ser estática, portanto a instância não tem a variável e sim a classe, então ela sendo incrementada a partir de uma chamada estatica ou local, não importa pois quem é incrementada é a variável.
E ela exibe 8 no final ao inves de 9 por que o método retorna
" return b++; " … ou seja… é um “pós-cremento” … ele retorna primeiro o valor da variavel ( 8 ) pra depois incrementar ( 9 ) …

Espero que eu tenha conseguido ser claro

Falei asneira atrás de asneira… :oops:

pardal_nb:

minha teoria do 8 e nao 9é outra …

nada com o pós-incremento…e sim com

neste momento ele nao soma +1 na variavel estática…ele apenas soma 1 ao retorno da variavel estatica…

se fosse,

ele estaria somando +1 na var estatica e a resposta seria 9

=)

certo, professor?

Verdade, ele não altera a variável. 5 e 8.

Mas, acho que não faz diferença ser pré ou pós incremento.

é verdade…

só falei m***a :oops: :oops: :oops:

rafaelglauber:

no ponto 1) 1
no ponto 2) 2

me confudi com “final” que de qualquer forma daria erro

5, 8

rafaelglauber:

no ponto 1) 1
no ponto 2) 2

Rafael, variáveis estáticas são variaveis da classe…e não do objeto…

abs

5 e 8 :?

vou de 5 e 9… pq 5 e 8? observe que o valor é compartilhado por ser static… e vc invoca 4 vezes apos a linha //1.

qual a resposta?

LPJava:

vou de 5 e 9… pq 5 e 8? observe que o valor é compartilhado por ser static… e vc invoca 4 vezes apos a linha //1.

qual a resposta?

pq o primeiro retorno eh 0

alias pessoal olha q detalhe…

package org.projeto;   
  
public class AcessarEstatico {   
  
    public AcessarEstatico() {   
        System.out.println(Estatico.incrementar());   // 0
        System.out.println(Estatico.incrementar());   //1
        System.out.println(Estatico.incrementar());   //2
        System.out.println(Estatico.incrementar());   //3
           
        Estatico x = new Estatico();   
           
        System.out.println("Valor de b: " + ++x.b); //  pegadinha aqui.. me confudi aqui é 4
           
        System.out.println("Valores: " + x.incrementar());   //5
        System.out.println("Valores: " + x.incrementar());   //6
        System.out.println("Valores: " + x.incrementar());   //7
        System.out.println("Valores: " + x.incrementar()); //8 
    }   
  
    public static void main(String[] args) {   
        new AcessarEstatico();   
  
    }   
  
}

hehe na linha la ++x, me confudi uauha pensando q ele tava incrementando o b… e na verdade ele incrementa a variavel de instancia… uhauha :D.
resposta 5 e 8.

LPJava:

vou de 5 e 9… pq 5 e 8? observe que o valor é compartilhado por ser static… e vc invoca 4 vezes apos a linha //1.

qual a resposta?

por ser um tipo primitivo, e nao ter seu valor inicializado, o valor default para byte é 0…

até

LPJava:

eu analisei dessa forma…

package org.projeto;   
  
public class AcessarEstatico {   
  
    public AcessarEstatico() {   
        System.out.println(Estatico.incrementar());   // 0
        System.out.println(Estatico.incrementar());   //1
        System.out.println(Estatico.incrementar());   //2
        System.out.println(Estatico.incrementar());   //3
           
        Estatico x = new Estatico();   
           
        System.out.println("Valor de b: " + ++x.b); //5  
           
        System.out.println("Valores: " + x.incrementar());   //6
        System.out.println("Valores: " + x.incrementar());   //7
        System.out.println("Valores: " + x.incrementar());   //8
        System.out.println("Valores: " + x.incrementar()); //9   
    }   
  
    public static void main(String[] args) {   
        new AcessarEstatico();   
  
    }   
  
}

só q nessa linha, System.out.println("Valores: " + x.incrementar()); //6, o valor eh 5 ainda…pq dentro do seu metodo eh utilizado pos incremento e nao pre…e na linha anterior ele nao usou o metodo para fazer a soma, entendeu?

A justificativa de LP ainda n está muito correta.

A resposta é 5 e 8 e a justificativa mais correta que vi até agora foi a do Omeganosferatu.

O resultado tem a ver com o fato de o membro b ser static e o operador no método incrementar ser pós-fixado.

RafaelVS:

A justificativa de LP ainda n está muito correta.

A resposta é 5 e 8 e a justificativa mais correta que vi até agora foi a do Omeganosferatu.

O resultado tem a ver com o fato de o membro b ser static e o operador no método incrementar ser pós-fixado.

so nao pode esquecer de levar em consideracao q tem hora q ele chama o pre-incremento …sem usar ometodo, óbvio rs…

ai em duas linhas ele printa na tela o numero 5…

pardal_nb:

RafaelVS:

A justificativa de LP ainda n está muito correta.

A resposta é 5 e 8 e a justificativa mais correta que vi até agora foi a do Omeganosferatu.

O resultado tem a ver com o fato de o membro b ser static e o operador no método incrementar ser pós-fixado.

so nao pode esquecer de levar em consideracao q tem hora q ele chama o pre-incremento …sem usar ometodo, óbvio rs…

ai em duas linhas ele printa na tela o numero 5…

Eh… nesse caso, isso soh muda o valor dessa linha, onde seria exibido 4 ao inves de 5 (se o operador fosse pos-fixado)… mas observe que na “linha 2” continuaria sendo exibido 8.

sim, sei disso…

por isso falei q seria 5 e 8

Respondeu certo quem falou 5 e 8. Por quê?

Simples. Já que temos o operador após a variável, o seu resultado não será somado de imediato.

Portanto se eu tenho:

b = 0;

b++;

System.out.println(b);

O resultado aqui será 0 e não 1. Somente se o operador fosse usado como prefixo. Sendo

++b;

Como conseqüencia, o primeiro "System.out.println(Estatico.incrementar());" apresentará o resultado de 0, porém o segundo já mostrará a soma dele anterior.

No ponto de:

System.out.println("Valor de b: "; + ++x.b);

O b está como 4, porém por estamos fazendo um acrescimento anterior da mostragem do resultado, b passa a ser 5 e não mais 4. Já no próximo println ele ainda será apresentado como 5 e não como 6 como alguns pensaram, seguindo a seqüência e terminando como 8.

Espero que tenham gostado, se alguma coisa não ficou clara, favor postar no tópico. Obrigado a todos.

package org.projeto;

public class AcessarEstatico {

	public AcessarEstatico() {
		System.out.println(Estatico.incrementar());
		System.out.println(Estatico.incrementar());
		System.out.println(Estatico.incrementar());
		System.out.println(Estatico.incrementar());
		
		Estatico x = new Estatico();
		
		System.out.println("Valor de b: " + ++x.b); // imprime 5
		
		System.out.println("Valores: " + x.incrementar());
		System.out.println("Valores: " + x.incrementar());
		System.out.println("Valores: " + x.incrementar());
		System.out.println("Valores: " + x.incrementar()); //imprime 8
	}

	public static void main(String[] args) {
		new AcessarEstatico();

	}

}

eu sempre acerto todas
hehehe
acho que faco a prova em janeiro da 5 e depois da 6
e uns [color=blue]AMEBAS[/color] ainda ficam me chamando de troll

Opa… compreendido…!!!

jjose:

eu sempre acerto todas
hehehe
acho que faco a prova em janeiro da 5 e depois da 6
e uns [color=blue]AMEBAS[/color] ainda ficam me chamando de troll

mas ti chamam de troll por seus topicos como esse: http://www.guj.com.br/posts/list/76335.java

Ae galera eu consertei o topico dar uma olhada… galera aqui é rapido nem esperou eu terminar de editar

Q TOPICO + TOSCO

Pessoal acho que está tendo um pouco de confução da minha parte… Alguem poderia me ajudar … Seguinte…
Minha dúvida é a seguinte
…o Grinvon
Mostro um trecho de codigo assim

b = 0;
b++;
System.out.println(b);// o resultado aqui é um 1 e não 0 como nossa amigo falow ....

Estou certo ne´? ou estou errado ?

qual a sua duvida?!
:?

LPJava:

jjose:

eu sempre acerto todas
hehehe
acho que faco a prova em janeiro da 5 e depois da 6
e uns [color=blue]AMEBAS[/color] ainda ficam me chamando de troll

mas ti chamam de troll por seus topicos como esse: http://www.guj.com.br/posts/list/76335.java

Ae galera eu consertei o topico dar uma olhada… galera aqui é rapido nem esperou eu terminar de editar :)

o que tem d+ nesse topico
nem fui eu quem arrumou briga
acho que eh um topico normal
vai falar que sou troll por isso
nada haver
soh quero entrar no panelinha

a dúvida é o seguinte nosso amigo Grivon mostro um trecho de codigo

b = 0;
b++
System.out.println(b);//ele falow que imprime 0 eu acho que imprimi 1 ....

…

Raff:

a dúvida é o seguinte nosso amigo Grivon mostro um trecho de codigo

b = 0;
b++
System.out.println(b);//ele falow que imprime 0 eu acho que imprimi 1 ....

…

e daí??? :evil:

hahahaha

(ps: o comentario ali eh seu ou do cara??)

Correto raff o resultado é 1, o que ele quis dizer, e que no caso de um retorno de metodo , ou atribuição quando se usa o operador de pos incremento b++, acontece o seguinte, ele retorna o resultado depois incrementa, ex:

class Teste {

  public static int incrementa(int num) {
     return num++;
   }

  public static void main(String [] args) {
    int b = 0;   
    System.out.println(Teste.incrementa(b));  
  }
}

O resultado deste programa é 0, se fosse ++num, o resultado seria 1.

Att

valew ai cara agora entendi

Grinvon:

Mais ou tópico de "Mais uma...". Estou fazendo essas questões por causa de um trabalho de aulas minhas, então eu crio as questões e jogo aqui no GUJ. Agora mais uma> :wink:

Você tem essa classe:

package org.projeto;

public class Estatico {
	
	public static byte b;
	
	public static byte incrementar() {
		return b++;
	}

}

E agora essa:

package org.projeto;

public class AcessarEstatico {

	public AcessarEstatico() {
		System.out.println(Estatico.incrementar());
		System.out.println(Estatico.incrementar());
		System.out.println(Estatico.incrementar());
		System.out.println(Estatico.incrementar());
		
		Estatico x = new Estatico();
		
		System.out.println("Valor de b: " + ++x.b); //1
		
		System.out.println("Valores: " + x.incrementar());
		System.out.println("Valores: " + x.incrementar());
		System.out.println("Valores: " + x.incrementar());
		System.out.println("Valores: " + x.incrementar()); //2
	}

	public static void main(String[] args) {
		new AcessarEstatico();

	}

}

Qual será o valor em 1 e qual será o valor em 2? Por quê?

Sou novo no forum...

Ei em...

System.out.println("Valor de b: " + ++x.b); //1

Ele não imprimiria x.b antes de fazer o incremento? A resposta não seria 4?