JOptionPane

Assuntos Gerais
#1

No codigo:

String nome = JOptionPane.showInputDialog("Digite seu nome:");

A variavel nome vai armazenar o que for digitado no JTextField de JOptionPane.showInputDialog(“Digite seu nome:”).
Mas, quando eu escrevo “Digite seu nome” , estou criando uma String por trás certo?
Algo parecido com isso:

String mensagem = "Digite seu nome";
String nome = JOptionPane.showInputDialog(mensagem);

Se sim, a melhor forma de evitar isso seria implementado uma interface com Strings constantes?

#2

Não tem como evitar. E também não tem sentido querer evitar.

#3

ViniGodoy,
estava pensando no seguinte…

public interface constantes{
public final String NOME = "NOME";
}

public class Cliente implements constantes{
public void setNomeCliente(){
JOptionPane.showInputDialog(NOME);
}
}

public class Filme implements constantes{
public void setNomeFilme(){
JOptionPane.showInputDialog(NOME);
}
}

public class Test {
//import...
	public static void main(String[] args) {
Filme filme = new Filme();
Cliente cliente = new Cliente();

String nomeCliente = cliente.setNomeCliente();
String nomeFilme = filme.setNomeFilme();
}
}

Obs:Não compilei esse codigo, criei aqui rapidao so pra mostrar…

Assim, estarei sempre chamando apenas uma String NOME da interface.Evitando a criação de mais uma String.
Estou pensando certo ou errado?

#4

Está pensando errado.

Todas as Strings criadas usando as somente aspas referem-se a mesma String, desde que tenham o mesmo valor.

Pode testar aí:

[code]String x = “Vinícius”;
String y = “Vinícius”;
String z = new String(“Vinícius”);

System.out.println(x == y); //Retorna true, são o mesmo objeto.
System.out.println(x == z); //Retorna true, são objetos diferentes.[/code]

De qualquer forma, ainda que fossem objetos diferentes, não teria porque poupar tão pouca memória desse jeito.

#5

Boa!
Nao estava pensando no objeto. Apenas na String em si. :?
Poderia me ajudar aqui?..
http://www.guj.com.br/java/290089-melhor-forma-de-se-mostrar-uma-string-
No ultimo post…

#6

[quote=ViniGodoy]Está pensando errado.

Todas as Strings criadas usando as somente aspas referem-se a mesma String, desde que tenham o mesmo valor.

Pode testar aí:

[code]String x = “Vinícius”;
String y = “Vinícius”;
String z = new String(“Vinícius”);

System.out.println(x == y); //Retorna true, são o mesmo objeto.
System.out.println(x == z); //Retorna true, são objetos diferentes.[/code]

De qualquer forma, ainda que fossem objetos diferentes, não teria porque poupar tão pouca memória desse jeito.[/quote]

Só para complementar, isso é o que chamamos de pool de Strings
Quando se usa o “new”, se cria um novo objeto num local chamado heap, já quando não se utiliza o “new” para as Strings, então as referencias são apontadas para esse pool de Strings.

#7

Qualquer objeto que eu criar, independente de seu tipo irá para esse heap?

#8

Somente alguns tipos de constantes, desde que criados como literais irão para o Pool.

Como por exemplo, Strings criadas com “”, objetos de wrappers de tipo primitivo (como os da classe Byte, Integer, Short, Double, Float), desde que criados de maneira literal, e desde que estejam no intervalo de -127 até 128 como:

Os demais, ficam na memória heap, que é a memória do micro.

#9

Sim, o operador “new” aloca sempre uma memoria diferente no heap por isso Strings com mesmo conteúdo, mas com a declaração de “new”, retornam false quando comparada por ==
existe também, uma memória chamada de steack, essa é para métodos e variáveis de métodos, e sempre é apagada quando o método termina.
Então sim todos os objetos vão para o heap, menos o caso das referencias de String que vão para o pool de String, e talvez também as Threads que vão para o pool de theads, mas essa não posso te afirmar.
Abraço.

#10

Ah, entendi!
Lá vamos nós…

Test a = new Test();
Test b = new Test();
Test c = a;

return (a == b)?true:false;   //Retornará false
return (a == c)?true:false;   //Retornará true
return (b == c)?true:false;   //Retornará false

Quando eu usar new em Test a, a JVM irá alocar um espaço na memória de heap que irá guardar os bits referentes a variavel a.
Quando eu usar new em Test b, a JVM irá alocar um espaço na memória de heap que irá guardar os bits referentes a variavel b. Porém, os bits referentes a b serão diferentes de a.
Quando eu definir que c = a, estarei passando para a variavel c o endereco de bits refentes a variavel a.

Concluindo…
O registro de a é diferente de b, pois sao duas referencias distintas.
O registro de c é o mesmo de a, pois tenho o mesmo registro que pode ser acessado por duas variaveis diferentes, certo?

ViniGodoy,
Não entendi muito bem o que você quiz dizer com “desde que criados como literais”…
Então quer dizer que se eu declarar uma variavel como null, esta vai para o heap e quando eu declarar uma variavel com algum literal esta vai para Pool?

#11

Literal é quando você digita o valor da variável diretamente no código.

Valores como “Vinícius”, 10, 4.557f.

Então, se você cria um objeto assim:

Integer x = 10; Integer y = 10; Integer z = new Integer(10);

Isso retorna true:

E isso false:

Mas cuidado que esse caso também é false:

Integer a = 500; Integer b = 500; System.out.println(a == b);

#12

Aqui tem uma boa explicação, mas ta em ingles.

http://www.javatutorialhub.com/java-stack-heap.html

#13

E se quiser REALMENTE se aprofundar:



#14