tipos - variables de referencia en java
¿Cuál es la diferencia entre referencias y objetos en java? (9)
¿Cuál es la diferencia entre referencias y objetos en java?
Una referencia es una entidad que proporciona una manera de acceder al objeto de su tipo. Un objeto es una entidad que proporciona una forma de acceder a los miembros de su clase o tipo.
En general, no puede acceder a un objeto sin una referencia a él.
class GUI
{
void aMethod()
{
// some business logic.
}
}
Puede llamar a un aMethod con o sin una referencia. Pero definitivamente necesitas un objeto.
Sin referencia:
new GUI().aMethod();
// you can''t reuse the object
// bad way to code.
Con referencia:
GUI aGUIReference = new GUI();
aGUIReference.aMethod();
// Now, the object can be reused.
// Preferred way to code
Ahora una pequeña explicación a tus líneas de código:
GUI g1 = new GUI();
// g1 is a reference to an object of GUI class.
GUI g2;
// g2 is a reference that can point to an object of GUI class
// but currently not pointing to any.
La única diferencia b / w g1 y g2 es que g1 se inicializa con un objeto pero g2 apunta a null
g2 = g1;
// it means g2 will point to the same object g1 is pointing to
// only one object but two references.
Esta pregunta ya tiene una respuesta aquí:
Tengo clase GUI para poder crear objetos como este:
GUI g1 = new GUI();
y una variable de referencia como esta:
GUI g2;
Ahora que sé, g2 es una variable de referencia que da referencia a la clase GUI y g1 es un objeto de la clase GUI. ¿Cuál es la diferencia entre g1 y g2? Puedo usar la propiedad de la clase GUI con un objeto, pero ¿cuál es el posible uso de g2?
Ambos, g1 y g2 son referencias. Pero g2 no está inicializado, por lo que no se puede utilizar en el código.
//Tells that g1 g2 should hold Gui object. Currently they are not holding any object.
Gui g1;
Gui g2;
//Now g1 reference holds object. g2 reference still doesn''t point to any object.
g1 = new GUI();
En realidad, en el nombre de Java de su variable es una referencia (excepto de los tipos primitivos). No puede utilizar g2 porque no se ha inicializado e incluso no es nulo. Obtendrá un error de tiempo de compilación al intentar llamar a un método para g2. Después de GUI g2; g2 no está apuntando a un objeto en la memoria. Si establece g2 en nulo como este GUI g2 = null; puede usarlo después de la declaración pero si llama a un método para g2 obtendrá una NullPointerException de tiempo de ejecución.
Las referencias son nombres. Los objetos son cosas. Puedes tener diferentes nombres para cosas, incluso para cosas que en realidad no existen.
Puedes declarar nombres, sin darles un significado "real", como este:
GUI g1;
Los nombres pueden cambiar su significado con el tiempo. El mismo nombre puede referirse a diferentes cosas en diferentes momentos.
GUI g1 = some_gui;
doSomething();
g1 = some_other_gui;
Eso es más o menos lo que hacen las referencias. Son nombres destinados a referirse a cosas.
Se pueden crear cosas:
new GUI();
Las cosas se pueden crear y nombrar en el momento para futuras referencias (¡literalmente!):
GUI g1 = new GUI();
:)
Las referencias son nombres. Los objetos son cosas. Puedes tener diferentes nombres para cosas, incluso para cosas que en realidad no existen.
Puedes declarar nombres, sin darles un significado "real", como este:
GUI g1;
Puede asignar significado (cosas reales para referirse) a los nombres con el operador =:
GUI g1 = some_gui;
Los nombres pueden cambiar su significado con el tiempo. El mismo nombre puede referirse a diferentes cosas en diferentes puntos de la historia.
GUI g1 = some_gui;
doSomething();
g1 = some_other_gui;
También hay sinónimos: varios nombres pueden referirse a lo mismo:
GUI g2 = g1;
Eso es más o menos lo que hacen las referencias. Son nombres destinados a referirse a cosas.
Se pueden crear cosas:
new GUI();
Las cosas se pueden crear y nombrar en el momento para futuras referencias (¡literalmente!):
GUI g1 = new GUI();
Y las cosas se pueden referir, usando su nombre (o cualquiera de sus nombres!):
g1.doSomething();
g2.doSomethingAgain();
Se pueden crear diferentes elementos del mismo tipo (clase), y nombrarse de manera diferente:
GUI g1 = new GUI();
GUI g2 = new GUI();
GUI g3 = new GUI();
GUI g1_synonym = g1;
:)
Los objetos son como burbujas que flotan a través de un espacio llamado montón. Las variables son simplemente enlaces a estas burbujas. La expresión new GUI() crea un objeto y el operador = vincula a la variable g1 . g2 también es una variable pero no está vinculada a ningún objeto. Puedes intercambiarlos fácilmente escribiendo
g2 = g1;
g1 = null;
Ahora g2 refiere al objeto al que g1 se refería al principio, y g1 refiere a nada. El objeto está intacto, solo se cambiaron las variables.
No puede usar g2 hasta que le asigne un objeto, ya que actualmente no apunta a ningún objeto, mientras que g1 ya apunta a un objeto GUI y puede usarlo.
Esta:
GUI g1 = new GUI();
es bastante equivalente a:
GUI g1;
g1 = new GUI();
Una referencia es un "gancho" donde puede colgar un objeto. Un objeto puede estar en más de un gancho.
References son una especie de punteros a un bloque de memoria llamados objects.
GUI g1 = new GUI();
Para la explicación, déjame romper la declaración anterior.
GUI g1;
g1 = new GUI();
1er paso: g1 es una variable de referencia (puntero), que aún no apunta a ninguna ubicación de memoria válida.
Segundo paso: el segundo paso asigna la memoria para el objeto de la GUI de clase y la operación de asignación hace que la variable de referencia g1 apunte a este objeto (ubicación de la memoria). La new palabra clave asigna la memoria para el objeto de la clase GUI .