Duda en paso de valores por referencia de Java

[arts]

Muy buenas tengo una duda un poco rara en el paso de valores por referencia, por ejemplo en el siguiente ejemplo:
Button A = new Button();
Button B = new Button();
Button C = B

Hasta aquí tengo 3 espacios de memoria verdad ? A, B y C solo que A apunto a un sitio, B a otro y C apunta al de B verdad?.
Ahora viene mi duda.
¿ Si ahora digo que B = A ?
Estaría haciendo paso por paso que A apunte a su sitio de siempre, B que tenía su espacio de memoria ahora apunte a A, pero en C que está mi duda apuntaba a B, pero al haber cambiado el apuntador de B se supone que ahora esta apunta a A, es decir todos apuntan a A ?. O por el contrario es más simple y seguiría C apuntando a B.

[visualfree]

¿ Si ahora digo que B = A ?
Estaría haciendo paso por paso que A apunte a su sitio de siempre, B que tenía su espacio de memoria ahora apunte a A, pero en C que está mi duda apuntaba a B, pero al haber cambiado el apuntador de B se supone que ahora esta apunta a A, es decir todos apuntan a A ?. O por el contrario es más simple y seguiría C apuntando a B.
A=L ==A Apunta L
B=A ==B Apunta A
C=B ==C C apunta B


Saludos

[arts]

Ok, es mas fácil que los puntero de c++. No se quedan direcciones de memoria guardadas. Al final A apuntab al sitio de siempre, B apunta a A y C a B.
Ok gracias !! 

[arts]

Mmm... he realizado una prueba y me ha dado resultados diferentes a los que se indican :/. Al parecer funciona según donde estén apuntando la última vez las instancias.
Dejo el ejemplo que he realizado por curiosidad y ha resultado ser diferente del esperado. Ya he entendido como funciona y no se si es que realmente no he entendido tu explicación o te has equivocado.

Código (java) [Seleccionar] Expandir

package PrimeraClase;
public class Constructores {
boolean valiente = false;
int edad;
String colorPelo;
double altura;

public Constructores(boolean valiente, int edad, String colorPelo, double altura ){
this.valiente = valiente;
this.edad = edad;
this.colorPelo = colorPelo;
this.altura = altura;
}

public Constructores(){
this.valiente = false;
this.edad = 0;
this.colorPelo = null;
this.altura = 0;
}

public static void main (String[] arg)
{
/*
new Persona().getNombre(); y
Persona p = new Persona();
p.getNombre();
Es que en el primero creas una referencia temporal para el objeto que esta creando new e invocas el metodo
y la variable es destruida temporal es destruida despues de esa linea mientras que en la segunda se genera
el objeto en el heap y se guarda esa direccion para que pueda ser usada posteriormente.
la variable p existira hasta que se salga del metodo donde se declaro o del bloque ({..}) donde se creo.
*/
// System.out.println(new Constructores().colorPelo = "marron");
Constructores pj = new Constructores(true, 30, "moreno", 1.9f);
Constructores pj1 = new Constructores(false,15,"rubio",1.4f);
Constructores pj2;


System.out.println("Datos de PJ");
System.out.println("El pj es valiente: "+pj.valiente);
System.out.println("El pj tiene: "+pj.edad+" años");
System.out.println("El pj es: "+pj.colorPelo);
System.out.println("El pj mide: "+pj.altura+" cm");
System.out.println("******************************************************************");
System.out.println("Datos de PJ1");
System.out.println("El pj1 es valiente: "+ pj1.valiente);
System.out.println("El pj1 tiene: "+pj1.edad+" años");
System.out.println("El pj1 es: "+pj1.colorPelo);
System.out.println("El pj1 mide: "+pj1.altura+" cm");
System.out.println("******************************************************************");
System.out.println("******************************************************************");
System.out.println("Ahora en pj1 apunta a pj por lo que debería salir lo mismo que pj");
pj1 = pj;
System.out.println("El pj1 es valiente: "+ pj1.valiente);
System.out.println("El pj1 tiene: "+pj1.edad+" años");
System.out.println("El pj1 es: "+pj1.colorPelo);
System.out.println("El pj1 mide: "+pj1.altura+" cm");
System.out.println("******************************************************************");
System.out.println("******************************************************************");
pj2 = pj1;
System.out.println("Ahora pj2 apunta a pj1 que a su vez pj1 ya estaba apuntando a pj por lo que debería salir lo mismo que pj");
System.out.println("El pj2 es valiente: "+ pj2.valiente);
System.out.println("El pj2 tiene: "+pj2.edad+" años");
System.out.println("El pj2 es: "+pj2.colorPelo);
System.out.println("El pj2 mide: "+pj2.altura+" cm");
}
}

Código [Seleccionar] Expandir

RESULTADOS
Datos de PJ
El pj es valiente: true
El pj tiene: 30 años
El pj es: moreno
El pj mide: 1.899999976158142 cm
******************************************************************
Datos de PJ1
El pj1 es valiente: false
El pj1 tiene: 15 años
El pj1 es: rubio
El pj1 mide: 1.399999976158142 cm
******************************************************************
******************************************************************
Ahora en pj1 apunta a pj por lo que debería salir lo mismo que pj
El pj1 es valiente: true
El pj1 tiene: 30 años
El pj1 es: moreno
El pj1 mide: 1.899999976158142 cm
******************************************************************
******************************************************************
Ahora pj2 apunta a pj1 que a su vez pj1 ya estaba apuntando a pj por lo que debería salir lo mismo que pj
El pj2 es valiente: true
El pj2 tiene: 30 años
El pj2 es: moreno
El pj2 mide: 1.899999976158142 cm


[ThinkByYourself]

En Java no existen los punteros (no de manera explícita, claro). Para saber más, tendrás que averiguar más sobre el garbage collector de Java.
Si buscas encuentras!! Hasta otra!
http://www.youtube.com/watch?v=wATBX_tNyUw
Byeeeee

[~ Yoya ~]

Muy buenas tengo una duda un poco rara en el paso de valores por referencia, por ejemplo en el siguiente ejemplo:
Button A = new Button();
Button B = new Button();
Button C = B

Hasta aquí tengo 3 espacios de memoria verdad ? A, B y C solo que A apunto a un sitio, B a otro y C apunta al de B verdad?.
Ahora viene mi duda.
¿ Si ahora digo que B = A ?
Estaría haciendo paso por paso que A apunte a su sitio de siempre, B que tenía su espacio de memoria ahora apunte a A, pero en C que está mi duda apuntaba a B, pero al haber cambiado el apuntador de B se supone que ahora esta apunta a A, es decir todos apuntan a A ?. O por el contrario es más simple y seguiría C apuntando a B.

En memoria de la maquina virtual de java existen dos espacio, Heap y Stack.

• En la memoria stack se almacenan las variables declaradas dentro de metodos, y se borrar automaticamente cuando el metodo finaliza su ejecuion.


• En la memoria Heap, se almacena los objetos creados.

Por lo tanto esto:

Código (java) [Seleccionar] Expandir


Button A = new Button();
Significa 3 cosas:

• Se crea una variable del Tipo Button en la memoria (stack si fue declarada dentro de un método, si fue declarada fuera de un metodo se crea en la memoria heap)
• Se crea un objeto Button en la memoria Heap
• Se le asigna la dirección donde se encuentra Button a la variable A

Eso significa que cuando le re-asignas un valor a una variable, esta cambia nomas la dirección donde se encuentra el nuevo objeto, y el objeto de antes se queda en la memoria heap. Si habia otro objeto apuntando al mismo objeto, este sigue apuntando al mismo objeto...

Si hay un punto en que el objeto no es utilizado por ninguna variable, entonce el objeto es elegible por el Garbage Collector para ser eliminado, pero este elige en que momento podrá ser eliminado o si llegara a eliminarlo.

Saludos.