Autor Tema: Paso de objetos como parámetros en Java por referencia o por valor. Manipulación  (Leído 13333 veces)

toni_apr

  • Avanzado
  • ****
  • Mensajes: 497
  • Curiosidad, es uno de los pilares del Conocimiento
    • Ver Perfil
Hola.

Hace tiempo que me ronda por la cabeza una duda que me plantean las opciones para pasar objetos como parámetros a las clases.

Me refiero a estas dos opciones.

La opción A:  (asignación por igualdad)
    public void setPersona(Persona persona1) { 
        persona = new Persona(persona1.getNombre(), persona1.getEdad());
    }
No me plantea ninguna duda. La considero perfecta e incorruptible. Se puede perder el objeto persona1 pues ya ha dado una copia de sus datos.

La duda la tengo en esta opción B: (asignación por identidad)
    public void setPersona(Persona persona1) {
        persona = persona1;
    }
Sobre esta opción he leido que si persona1 cambia más tarde, tal vez ¿? el objeto persona cambie en la misma forma sin haberlo decidido yo así.

He creado el código que adjunto en el mensaje intentando simular ese cambio inesperado, y he aquí la salida que obtengo:

Salida.txt
Código: [Seleccionar]
Fecha: 23/03/2015 > 02:06:01                               
01) Creados agentes: ag[0] = new Agente("A00",30)               y ag[1] = new Agente("A11",31)
02) ag[0]. ref.: ...Agente@143e87d                              ag[1]. ref.: ...Agente@1549b82
03) ····················idAgente: A00                           ····················idAgente: A11
04) ···········ExperienciaPuntos: 30                            ···········ExperienciaPuntos: 31
                                                           
05) Creados perros: pe[0] = new Perro("Labrador",false)         y  pe[1] = new Perro("Dogo",true)
06) pe[0]. ref.: ...Perro@1ad81d2                               pe[1]. ref.: ...Perro@262adc
07) ························Raza: Labrador                      ························Raza: Dogo
08) ················Esterilizado: false                         ················Esterilizado: true
                                                           
09) Creados equipos: eq[0] = new Equipo("Equipo A",ag[0],pe[0]) y  eq[1] = new Equipo("Mister T",ag[1],pe[1])
10) eq[0]<alias,ag,pe>. Ref.: ...Equipo@1c7d5b2                 eq[1]<alias,ag,pe>. Ref.: ...Equipo@9e9a07
11) ·······················Alias: Equipo A                      ·······················Alias: Mister T
12) Ref. agente: ...Agente@143e87d                              Ref. agente: ...Agente@1549b82
13) ····················idAgente: A00                           ····················idAgente: A11
14) ···········ExperienciaPuntos: 30                            ···········ExperienciaPuntos: 31
15) Ref. perro: ...Perro@927633                                 Ref. perro: ...Perro@18e2a42
16) ························Raza: Labrador                      ························Raza: Dogo
17) ················Esterilizado: false                         ················Esterilizado: true
                                                           
18) Asignación de identidad. ag[0] = ag[1]                      Asignación de identidad. pe[0] = pe[1]
19) ag[0]. ref.: ...Agente@1549b82                              ag[1]. ref.: ...Agente@1549b82
20) ····················idAgente: A11                           ····················idAgente: A11
21) ···········ExperienciaPuntos: 31                            ···········ExperienciaPuntos: 31
22) pe[0]. ref.: ...Perro@262adc                                pe[1]. ref.: ...Perro@262adc
23) ························Raza: Dogo                          ························Raza: Dogo
24) ················Esterilizado: true                          ················Esterilizado: true
25) eq[0]<alias,ag,pe>. Ref.: ...Equipo@1c7d5b2                 eq[1]<alias,ag,pe>. Ref.: ...Equipo@9e9a07
26) ·······················Alias: Equipo A                      ·······················Alias: Mister T
27) Ref. agente: ...Agente@143e87d                              Ref. agente: ...Agente@1549b82
28) ····················idAgente: A00                           ····················idAgente: A11
29) ···········ExperienciaPuntos: 30                            ···········ExperienciaPuntos: 31
30) Ref. perro: ...Perro@927633                                 Ref. perro: ...Perro@18e2a42
31) ························Raza: Labrador                      ························Raza: Dogo
32) ················Esterilizado: false                         ················Esterilizado: true
                                                           
33) Objeto nuevo. ag[0] =  new Agente()                         Objeto nuevo. pe[0] = new Perro()
34) ag[0]. ref.: ...Agente@1419cf7                              ag[1]. ref.: ...Agente@1549b82
35) ····················idAgente: Sin Id                        ····················idAgente: A11
36) ···········ExperienciaPuntos: 0                             ···········ExperienciaPuntos: 31
37) pe[0]. ref.: ...Perro@b44131                                pe[1]. ref.: ...Perro@262adc
38) ························Raza: Desconocida                   ························Raza: Dogo
39) ················Esterilizado: false                         ················Esterilizado: true
40) eq[0]<alias,ag,pe>. Ref.: ...Equipo@1c7d5b2                 eq[1]<alias,ag,pe>. Ref.: ...Equipo@9e9a07
41) ·······················Alias: Equipo A                      ·······················Alias: Mister T
42) Ref. agente: ...Agente@143e87d                              Ref. agente: ...Agente@1549b82
43) ····················idAgente: A00                           ····················idAgente: A11
44) ···········ExperienciaPuntos: 30                            ···········ExperienciaPuntos: 31
45) Ref. perro: ...Perro@927633                                 Ref. perro: ...Perro@18e2a42
46) ························Raza: Labrador                      ························Raza: Dogo
47) ················Esterilizado: false                         ················Esterilizado: true


En la salida del programa presento en dos columnas los dos elementos de cada array: agente, perro y equipo creados. Cada clase tiene sus propios atributos y en la clase Equipo dos atributos son de tipo Agente y Perro.

En la clase Equipo el atributo de tipo Perro lo inicializo o modifico siempre con la opción A, citada arriba (establezco una asignación de igualdad), y el atributo de tipo Agente lo modifico con la opción B, (establezco siempre una asignación de identidad).

Cada vez que en la salida se muestra un objeto, adjunta va una referencia que Java crea única para ese objeto (es la respuesta que da el método toString(), no sobreescrito a propósito para poder mostrar esa información.)
Esto que yo llamo referencia, supongo que viene a ser una forma que tiene Java de ligar el objeto en cuestión con los datos de este objeto en la memoria. ¿?
Esta referencia cambia en cada ejecución (la memoria no debe ser igual en todo momento).

En la salida, hasta la línea 17 se crean y presentan los objetos.
En la línea 18 se modifican un objeto de tipo Agente y otro de tipo Perro.
Hasta la línea 32 se vuelven a mostrar todos los objetos.
En la línea 33 se vuelven a modificar los mismos objetos de tipo Agente y de tipo Perro.
Y hasta el final se vuelven a mostrar todos los objetos.


En la información mostrada, se observa lo siguiente:

El objeto pe[1] que no se ha modificado en ningún momento, mantiene sus atributos y su referencia en todo momento. Este mismo objeto al colocarlo dentro del  objeto equipo, cambia su referencia y la mantiene siempre dentro del objeto equipo (pues su asignación ha sido por igualdad).

El objeto pe[0] al que se le han hecho cambios, cambia su contenido y también su referencia en cada cambio. Una vez este objeto se coloca dentro del objeto equipo, cambia su referencia y la mantiene junto con los datos.

El objeto ag[1] que no se ha modificado en ningún momento, mantiene su referencia incluso dentro del objeto equipo (pues su asignación es por identidad), tampoco cambian sus datos.

El objeto ag[0] al que se le han hecho cambios, cambia su contenido cada vez al igual que su referencia. Al colocarlo dentro del objeto equipo, mantiene sus datos en todo momento al igual que su referencia (que es la misma que en su creación antes de modificar el objeto).

El objeto eq[1] mantiene su referencia en todo momento aunque han cambiado algunas referencias internas. Nunca cambian los datos.

El objeto eq[0] mantiene su referencia en todo momento aunque cambian algunas referencias internas así como datos.


Conclusión:
No se pierden datos de objetos pasados como parámetros tanto si se usa la opción A -era previsible-, como la B -en la que tenía dudas-
Si existe el riesgo a que un atributo inicializado o actualizado con un objetoZ revierta su contenido al cambiar externamente el objetoZ debe ser a un nivel muy profundo y que yo no sé reproducir.

Os pido vuestros comentarios después de haber mascullado/triturado todo el mamotreto anterior. Gracias por vuestra opinión.

Saludos
« Última modificación: 24 de Marzo 2015, 09:13 por Alex Rodríguez »

Dan_SB

  • Avanzado
  • ****
  • Mensajes: 273
  • *<DanielsCK>*
    • Ver Perfil
Re:Dudas pasando objetos como parámetros en Java
« Respuesta #1 en: 24 de Marzo 2015, 02:56 »
Hola!!

Tony, pregunta, ¿Porque en setPersona tienes "persona = new Persona(persona1.getNombre(), persona1.getEdad()?. Se supone que estas cargando datos, no comprendo :s
"Luchar por tus sueños y cumplirlos... eso es vivir.."

Alex Rodríguez

  • Moderador Global
  • Experto
  • *******
  • Mensajes: 2050
    • Ver Perfil
Hola toni, no sé si voy a ser capaz de responder a todas las cuestiones que puedan surgir, aunque podemos intentarlo.

Citar
Sobre esta opción he leido que si persona1 cambia más tarde, tal vez ¿? el objeto persona cambie en la misma forma sin haberlo decidido yo así.

Sí, es tal como comentas. No es cuestión de que decidas o no decidas, sino simplemente de que se trata de referencias a un mismo espacio de memoria, un mismo objeto. Por eso si cambia el objeto, ambas referencias reflejarán dicho cambio (esto puede parecer algo involuntario en el sentido de que el cambio lo origina una de las referencias, pero afecta a ambas, en ese sentido se puede decir que hace algo que no has decidido, pero esto es una forma de hablar).


Una cosa que observo es que estás prestando atención a la referencia que devuelve el método toString() cuando no lo has sobreescrito. Por ejemplo Agente@d09ad0  como referencia de un agente. No creo que sea buena idea en el sentido de que esta referencia es algo propio de la operación interna del compilador y de la gestión de memoria que haga java, por tanto algo que no podemos controlar y algo que diríamos "impredecible". Por ejemplo, supongamos que un objeto tiene como referencia Agente@d09ad0. Dicha referencia no es controlada por nosotros ni sabemos los mecanismos que la controlan, por tanto podría cambiar arbitrariamente según cierta lógica que desconocemos. Si usamos esta referencia para programar o analizar lo que ocurre es posible que no obtengamos resultados coherentes (o quizás sí, de ahí que no me parezca buena idea su uso).

He creado un pequeño código de prueba:

Código: [Seleccionar]
public class Test {   

    public static void main (String[] args) {
        Agente ag1 = new Agente("id1", 33);
        Agente ag2 = new Agente("id2", 44);

        System.out.println ("Antes de establecer identidad:\n"+ag1 + "\n"+ag2);
        System.out.println ("Antes de establecer identidad el agente1 tiene puntos: "+ag1.getExperienciaPuntos());
       
        ag1=ag2;
       
        System.out.println ("Después de establecer identidad:\n"+ag1 + "\n"+ag2);
        System.out.println ("Después de establecer identidad el agente1 tiene puntos: "+ag1.getExperienciaPuntos());
       
        System.out.println ("Ahora modificamos el agente 2 y establecemos que tiene 220 puntos");
        ag2.setExperienciaPuntos(220);
       
        System.out.println ("Ahora el agente1 tiene puntos: "+ag1.getExperienciaPuntos());
        System.out.println ("Ahora el agente2 tiene puntos: "+ag2.getExperienciaPuntos());

       
    }
} // Fin de la clase TestEquipo

El resultado de ejecución es este:

Antes de establecer identidad:
Agente@10079c0
Agente@11ecbae
Antes de establecer identidad el agente1 tiene puntos: 33
Después de establecer identidad:
Agente@11ecbae
Agente@11ecbae
Después de establecer identidad el agente1 tiene puntos: 44
Ahora modificamos el agente 2 y establecemos que tiene 220 puntos
Ahora el agente1 tiene puntos: 220
Ahora el agente2 tiene puntos: 220


Lo veo todo coherente. Una vez establecida la relación de identidad, da igual qué referencia modifiquemos, que al estar apuntando ambas referencias al mismo objeto, las dos referencias quedan modificadas.

Ahora tendríamos otro punto de análisis: el paso de objetos como parámetros

Java es un poco especial porque cuando pasas un objeto no pasas el objeto en sí, sino una referencia (a la posición de memoria) del objeto.


Copio desde otro hilo:

PREGUNTA:   ¿Los parámetros en Java se pasan por valor o por referencia? (Diferencia entre ambos sistemas discutida en http://aprenderaprogramar.com/index.php?option=com_content&view=article&id=144:modulos-genericos-y-paso-de-parametros-por-valor-byval-o-por-referencia-byref-ejemplos-cu00207a&catid=36:curso-qbases-de-la-programacion-nivel-iiq&Itemid=60 y siguientes entregas de ese curso)

RESPUESTA:

A veces se piensa erróneamente que los tipos primitivos pasan por valor y los objetos por referencia, pero esto no es así. Todo parámetro pasa por valor.

La confusión radica en que cuando pasamos un tipo primitivo, este no es modificable dentro del método. En cambio, al pasar un objeto, sí se pueden producir modificaciones dentro del método. Pero la realidad es que cuando pasamos el parámetro no pasamos el objeto en sí, sino una referencia al objeto, y esta referencia es la que pasa por valor y funciona como una copia dentro del método, resultando que los cambios dentro del método no son conocidos luego fuera de él.


He hecho este pequeño código de prueba:

Código: [Seleccionar]
public class Test2 {   

    public static void main (String[] args) {
        Agente ag1 = new Agente("id1", 33);
        Agente ag2 = new Agente("id2", 44);
        System.out.println ("Ahora el agente1 tiene puntos: "+ag1.getExperienciaPuntos());
        System.out.println ("Ahora el agente2 tiene puntos: "+ag2.getExperienciaPuntos());
   
        System.out.println ("Pasamos al agente 1 como parámetro a probarAsignar y lo modificamos ");
        probarAsignar(ag1);
   System.out.println ("Ahora el agente1 tiene puntos: "+ag1.getExperienciaPuntos());
   System.out.println ("Esto ocurre porque lo que se pasa es una copia de la referencia");

   System.out.println ("Pasamos al agente 1 como parámetro a probarModificar y lo modificamos ");
   probarModificar(ag1);
   System.out.println ("Ahora el agente1 tiene puntos: "+ag1.getExperienciaPuntos());
   System.out.println ("Esto ocurre porque a través de la copia hemos modificado el objeto, aunque luego la copia se pierda los cambios al objeto permanecen");

   
    }
   
    public static void probarAsignar(Agente agX) {
        Agente ag3 = new Agente("id3", 66);
        agX=ag3;
    }
   
    public static void probarModificar(Agente agX) {
        agX.setExperienciaPuntos(99);
       
    }
}

El resultado es: Ahora el agente1 tiene puntos: 33
Ahora el agente2 tiene puntos: 44
Pasamos al agente 1 como parámetro a probarAsignar y lo modificamos
Ahora el agente1 tiene puntos: 33
Esto ocurre porque lo que se pasa es una copia de la referencia
Pasamos al agente 1 como parámetro a probarModificar y lo modificamos
Ahora el agente1 tiene puntos: 99
Esto ocurre porque a través de la copia hemos modificado el objeto, aunque luego la copia se pierda los cambios al objeto permanecen



Esto también parece coherente: el método usa como parámetro una copia local de la referencia. Las modificaciones a la referencia no permanecen porque la copia se destruye posteriormente. En cambio, si usamos la referencia para manipular el objeto, dichos cambios sí permanecen porque a través de la copia hemos accedido a modificar el objeto en sí.

Un poco lioso pero creo que de momento no han surgido inconsistencias...

Saludos

toni_apr

  • Avanzado
  • ****
  • Mensajes: 497
  • Curiosidad, es uno de los pilares del Conocimiento
    • Ver Perfil
Gracias Dan y Alex por vuestra atención.

Alex, me voy a tomar mi tiempo para leer tu respuesta y poder contestarte.

Respecto a tu pregunta Dan, primero muestro la signatura del constructor de la clase Persona

    public Persona(String nombre, int edad)

Cuando creamos un objeto de tipo Persona invocando su constructor podemos hacerlo de estas formas:

1- persona = new Persona("Juan",20)
2- persona = new Persona(valorNombre, valorEdad)
3- persona = new Persona(persona1.getNombre(),persona1.getEdad())

En los tres casos lo que hay entre los paréntesis de Persona son dos valores separados por una coma, el primer valor es un texto.
En el caso 1- un texto encerrado entre comillas
En el caso 2- una variable de tipo String que contiene el nombre de la persona
Y en el case 3- hay un método, un getter, que como sabes devuelve un valor.
En este caso es el getter de un objeto de tipo Persona llamado persona1

De la misma forma el método setPersona cuya signatura sería:

    public void setPersona(Persona persona1)

en su interior tiene el código que te extraña. Y que es el tercer caso del constructor citado

Una cosa muy parecida al comentario a tu ejercicio CU00641B

Saludos

toni_apr

  • Avanzado
  • ****
  • Mensajes: 497
  • Curiosidad, es uno de los pilares del Conocimiento
    • Ver Perfil
Hola Alex

Gacias por tus comentarios. He de decirte que tu escrito no tiene derperdicio para mí.

Tengo claro que dos objetos idénticos cambian al modificar cualquiera de ellos. Para mí son dos puntos de vista (los dos objetos) de un paquete de información único.

Se que la nombrada 'referencia' que da el método toString() no sobreescrito, es una referencia que no podemos controlar, que cambia en cada ejecución.
Para mí es solo una forma visual de comprobar la identidad entre objetos.
Se me hacía más lioso crear una tabla con las relaciones de identidad de cada objeto con el resto de ellos.

Tu clase Test es clarificadora y ejemplarizante. También veo coherencia en la salida mostrada.


Citar
RESPUESTA:

A veces se piensa erróneamente que los tipos primitivos pasan por valor y los objetos por referencia, pero esto no es así. Todo parámetro pasa por valor.

La confusión radica en que cuando pasamos un tipo primitivo, este no es modificable dentro del método. En cambio, al pasar un objeto, sí se pueden producir modificaciones dentro del método. Pero la realidad es que cuando pasamos el parámetro no pasamos el objeto en sí, sino una referencia al objeto, y esta referencia es la que pasa por valor y funciona como una copia dentro del método, resultando que los cambios dentro del método no son conocidos luego fuera de él.

La cita anterior, es maná para mí. Desaloja casi todas las dudas que me planteaba pasar objetos como parámetros.

Y finalmente

Citar
Esto también parece coherente: el método usa como parámetro una copia local de la referencia. Las modificaciones a la referencia no permanecen porque la copia se destruye posteriormente. En cambio, si usamos la referencia para manipular el objeto, dichos cambios sí permanecen porque a través de la copia hemos accedido a modificar el objeto en sí.

En esta cita muestras la diferencia entre 'hacer modificaciones a la referencia' que ha llegado como copia del original, en el método  probarAsignar(Agente agX), y  'usar la propia referencia para modificar el objeto' en el método probarModificar(Agente agX). Cambios estos últimos que si trascienden, aunque esta referencia desaparezca al terminar el método.

He de decirte que no me había planteado (por ignorarlo) usar el parámetro recibido para modificar el objeto original.
Yo simplemente partía de la premisa de que un método set modifica su atributo y  nada más.


Mis conclusiones después de tus aportaciones son:

Los objetos idénticos manipulan el mismo objeto. Cualquier cambio en uno afeca al resto de idénticos.

Los cambios hechos en el parámetro que recibe un método son responsabilidad del programador. Es decir si usa el parámetro para otra cosa que no sea transmitir los datos a los que apunta, allá el programador con sus consecuencias.

Los cambios hechos a un objeto después de haberlo enviado como parámetro a un método. No afectan a los cambios que realizó la copia del objeto dentro del método.
Esta última observación, es la que me planteaba dudas. Y aquí se han desvanecido.

Ejem. Líneas de código sueltas sobre la cuestión:

    personaOriginal.setNombre("Victor");
    objetoPadre.setPersona(personaOriginal);
    ...
    public void setPersona(Persona persona1) {
        persona = persona1;
    }
    ...
    personaOriginal.getNombre() -> devuelve -> "Victor"
    objetoPadre.getPersona.getNombre() -> devuelve -> "Victor"
    ...
    personaOriginal.setNombre("Zenon");
    ...
    personaOriginal.getNombre() -> devuelve -> "Zenon"
    objetoPadre.getPersona.getNombre() -> devuelve -> "Victor"


Creo que no he dicho nada erróneo. Si he hecho suposiciones incorrectas apreciaré que me rectifiques.

Saludos y gracias.

Alex Rodríguez

  • Moderador Global
  • Experto
  • *******
  • Mensajes: 2050
    • Ver Perfil
Hola Toni, me alegro de haber servido de ayuda. Estas cuestiones que estamos hablando tienen su dificultad conceptual y no siempre resulta fácil abordarla.

Citar
Tengo claro que dos objetos idénticos cambian al modificar cualquiera de ellos. Para mí son dos puntos de vista (los dos objetos) de un paquete de información único.

Sí, diríamos que son dos referencias al mismo objeto.



Citar
Cambios estos últimos que si trascienden, aunque esta referencia desaparezca al terminar el método.

Sí, este concepto muchas veces no lo tienen claro programadores con cierta experiencia en Java y genera errores en los programas.


Citar
Los objetos idénticos manipulan el mismo objeto. Cualquier cambio en uno afecta al resto de idénticos.

Sí, todas las referencias que apunten a un objeto permiten acceder a manipularlo. Una manipulación en una referencia puede inducir cambios que no se esperaran cuando se trata de acceder al objeto a través de otra referencia.



Citar
Los cambios hechos en el parámetro que recibe un método son responsabilidad del programador. Es decir si usa el parámetro para otra cosa que no sea transmitir los datos a los que apunta, allá el programador con sus consecuencias.

Sí, el programador tiene que ser consciente de lo que hace. Si hace una manipulación siendo consciente no habrá problemas. El problema puede venir si no conoce estas formas de funcionamiento y hace cambios que generen efectos colaterales que no controla.


Creo que no hay nada incorrecto al menos a nivel conceptual. En cuanto a terminología es un poco confuso por la propia nomenclatura de java, de todas formas te recomendaría que trataras de expresar los conceptos siguiendo esta terminología:

Referencia: es cualquier elemento declarado en Java que apunta a un objeto.

Objeto: elemento compuesto de datos y métodos que ocupa un espacio de memoria.

Las referencias apuntan a objetos. Normalmente cada referencia apunta a un objeto, pero puede ocurrir que dos o más referencias apunten al mismo objeto (coloquialmente se dice que los dos objetos presentan relación de identidad. Digo coloquialmente porque en realidad no hay dos objetos, hay un solo objeto).

La frase "Tengo claro que dos objetos idénticos cambian al modificar cualquiera de ellos." quedaría entonces redactada "Tengo claro que dos referencias que apuntan al mismo objeto pueden inducir cambios en el objeto, se acceda al mismo a través de una u otra".

A pesar de esto no hay una nomenclatura del todo clara en parte porque el propio java no la tiene, de ahí que sea admisible expresarse de una forma u otra.

Saludos cordiales

toni_apr

  • Avanzado
  • ****
  • Mensajes: 497
  • Curiosidad, es uno de los pilares del Conocimiento
    • Ver Perfil
Hola Alex

Tomo nota de tus recomendaciones.
Me hago cargo que mi nomenclatura 'particular' choca con la que se usa en el mundo de Java. Voy a poner empeño en enmendar eso.

Quiero agradecerte la dedicación que me prestas. Y abusando de ella te traslado mis cavilaciones para que me enmiendes si es el caso.

A los conceptos:

Campo de clase
Atributo
Variable

se les identifica con un nombre (véase: precio, edad, taxi1, etc.) del que podemos decir que es una referencia ya sea al primitivo o al objeto creado

Si la referencia apunta a un objeto, también podemos decir que es una referencia a una instancia de una clase

En el transcurso de la vida de un objeto, nunca nos comunicamos con el objeto sino con su referencia o referencias (si hay varias)

Pensando en el nombre que se utiliza para bautizar la referencia a un objeto
(Véase persona1 en la instrucción: Persona persona1 = new Persona())

¿Es incorrecto decir:?
1   el objeto persona1 tiene esto y aquello...

¿Es correcto decir:?
2   la referencia persona1 a un objeto de tipo Persona tiene esto y aquello...
   o
3   la instancia persona1 de la clase Persona tiene esto y aquello...

La frase 1 la entiende todo el mundo, aunque persona1 no es un objeto sino una referencia a un objeto.
Entonces ¿cómo debe nombrarse un objeto dentro de una exposición si lo único que tenemos disponible es el nombre que tiene la referencia a ese objeto.?
Se me hace difícil reprimir el uso de la palabra objeto cuando se habla instancias de clase en Java:

Alex, me detengo aquí, porque esto se alargaría.

Apreciaré tus indicaciones.

Saludos.

Alex Rodríguez

  • Moderador Global
  • Experto
  • *******
  • Mensajes: 2050
    • Ver Perfil
Hola toni

Citar
En el transcurso de la vida de un objeto, nunca nos comunicamos con el objeto sino con su referencia o referencias (si hay varias)

Esto lo expresaría así: En el transcurso de la vida de un objeto, para comunicarnos o acceder al objeto no lo hacemos directamente, sino a través de su referencia, o referencias (si hay varias)



Citar
¿Es incorrecto decir:?
1   el objeto persona1 tiene esto y aquello...


Coloquialmente se usa, y es algo aceptado. Por tanto no vamos a pretender ir en contra de algo que hace toda la comunidad de programadores. Pero si tratáramos de ser más formales o técnicos tendríamos que decir que persona1 es una referencia y que el objeto referenciado por persona1 tiene esto y aquello...


Citar
¿Es correcto decir:?
2   la referencia persona1 a un objeto de tipo Persona tiene esto y aquello...

Yo diría mejor: el objeto referenciado por persona1 tiene esto y aquello...


Citar
la instancia persona1 de la clase Persona tiene esto y aquello...

Es algo aceptado hablar así, no vamos a pretender cambiarlo.


Citar
Entonces ¿cómo debe nombrarse un objeto dentro de una exposición si lo único que tenemos disponible es el nombre que tiene la referencia a ese objeto.?
Se me hace difícil reprimir el uso de la palabra objeto cuando se habla instancias de clase en Java:


No veo necesario reprimirlo, lo único que veo necesario es saber en qué contexto de conversación puede ser necesario ser más precisos (y hablar de referencias por ejemplo) y cuándo no es realmente necesario (y coloquialmente podemos decir que la referencia es un objeto o instancia de clase).


En resumen, según en qué contexto estemos hablando veo razonable ser más flexible en la terminología. Por ejemplo con vistas a la didáctica creo preferible inicialmente no hablar de referencias, sino de objetos, porque es más fácil de entender. Sólo cuando una persona ya tiene algo de rodaje sería cuando a lo mejor en algunos contextos puede ser interesante hablar de referencias.

Saludos

toni_apr

  • Avanzado
  • ****
  • Mensajes: 497
  • Curiosidad, es uno de los pilares del Conocimiento
    • Ver Perfil
Gracias Alex

Voy a guardar tus precisiones como oro en paño.

Saludos y hasta otra.

 

Sobre la educación, sólo puedo decir que es el tema más importante en el que nosotros, como pueblo, debemos involucrarnos.

Abraham Lincoln (1808-1865) Presidente estadounidense.

aprenderaprogramar.com: Desde 2006 comprometidos con la didáctica y divulgación de la programación

Preguntas y respuestas

¿Cómo establecer o cambiar la imagen asociada (avatar) de usuario?
  1. Inicia sesión con tu nombre de usuario y contraseña.
  2. Pulsa en perfil --> perfil del foro
  3. Elige la imagen personalizada que quieras usar. Puedes escogerla de una galería de imágenes o subirla desde tu ordenador.
  4. En la parte final de la página pulsa el botón "cambiar perfil".