martes
oct162012
Pregunta de examen: tipos primitivos y paso de valores
Buenos días,
¿Os atrevéis a responder sobre qué salida aparecería por consola en la ejecución del siguiente programa?
package javahispano;
/**
*
* @author jcarmonaloeches
*/
public class PreguntaDEExamne {
public static Long l = new Long(5);
public static String l2 = new String("5");
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
sayHello(l, l2);
System.out.println("l:"+l+" l2:"+l2);
}
private static void sayHello(Long l2, String l3) {
l2 = new Long(10);
l3 = new String("10");
}
}
Saludos cordiales,
tagged 
certificacion in ocjp
certificacion in ocjp
Reader Comments (14)
Ninguna porque no hay ningun print
touché, segundo asalto
public static void main(String[] args) {
sayHello(l, l2);
System.out.println("l:"+l+" l2:"+l2);
}
Me voy a poner "picajoso" ;D
En primer lugar, reescribiría la clase así:
public class PreguntaDEExamne {
private static Long l = 5L;
private static String l2 = "5";
/**
@param args the command line arguments
*/
public static void main(String[] args) {
sayHello(l, l2);
System.out.println("l:" + l + " l2:" + l2);
}
private static void sayHello(Long l2, String l3) {
l2 = Long.valueOf(10);
l3 = "10";
}
}
No hay necesidad de crear objetos innecesariamente, y sí conviene aprovechar las características de caché del Hotspot.
Los parámetros del método están "muertos": su valor inicial (el que se pasa como parámetro) no se usa.
La reasignación de valores a esos parámetros se hace local, y tampoco se usan.
El resultado es que ese método literalmente no hace nada.
Ok, cambiamos el guión, ¿cuál es la salida del siguiente programa?
package javahispano;
public class PreguntaDeExamen {
private static Long l = 5L;
private static String l2 = "5";
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
PreguntaDeExamen preguntaDeExamen = new PreguntaDeExamen();
preguntaDeExamen.cambiaValores(l, l2);
System.out.println("l:" + l + " l2:" + l2);
}
private void cambiaValores(Long l2, String l3) {
this.l = Long.valueOf(10);
this.l2 = "10";
}
}
La clase se podría reescribir así:
public class PreguntaDeExamen {
private static Long l = 5L;
private static String l2 = "5";
/**
@param args the command line arguments
*/
public static void main(String[] args) {
PreguntaDeExamen.l = Long.valueOf(10);
PreguntaDeExamen.l2 = "10";
System.out.println("l:" + l + " l2:" + l2);
}
}
que hace exactamente lo mismo.
Los parámetros del método no se usan, puesto que hace una asignación directa a campos de la clase. En este caso el método podría perfectamente escribirse sin parámetros, con idéntico resultado:
private void cambiaValores() {
PreguntaDeExamen.l = Long.valueOf(10);
PreguntaDeExamen.l2 = "10";
}
ok, siguiente pregunta:
package javahispano;
import java.util.ArrayList;
import java.util.List;
public class PreguntaDeExamen {
private static Long l = 5L;
private static String l2 = "5";
private static List c1 = new ArrayList();
private static List c2 = new ArrayList();
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
PreguntaDeExamen preguntaDeExamen = new PreguntaDeExamen();
preguntaDeExamen.cambiaValores(preguntaDeExamen.l, preguntaDeExamen.l2, c1, c2);
System.out.println("l:" + l + " l2:" + l2 + "c1.size: " + c1.size() + " c2.size: " + c2.size());
}
private void cambiaValores(Long l2, String l3, List c1, List c2) {
l2 = 10L;
l3 = "20";
c2.add("5");
c1 = new java.util.ArrayList();
c1.add("5");
}
}
Prefiero usar genéricos, aunque el resultado no cambia por ello:
public class PreguntaDeExamen {
private static Long l = 5L;
private static String l2 = "5";
private static List<String> c1 = new ArrayList<String>();
private static List<String> c2 = new ArrayList<String>();
/**
@param args the command line arguments
*/
public static void main(String[] args) {
PreguntaDeExamen preguntaDeExamen = new PreguntaDeExamen();
preguntaDeExamen.cambiaValores(preguntaDeExamen.l, preguntaDeExamen.l2, c1, c2);
System.out.println("l:" + l + " l2:" + l2 + "c1.size: " + c1.size() + " c2.size: " + c2.size());
}
private void cambiaValores(Long l2, String l3, List<String> c1, List<String> c2) {
l2 = 10L;
l3 = "20";
c2.add("5");
c1 = new java.util.ArrayList<String>();
c1.add("5");
}
}
Nuevamente nos encontramos con parámetros como l2 y l3 que, como en los ejemplos anteriores, están "muertos".
El caso de c1 es significativo, y parecido a los anteriores: aunque se reasigne un valor al parámetro, el nuevo valor de la lista sigue siendo local al método cambiaValores. La lista c1 solamente contiene el valor "5" dentro del método. Una vez que el método termina, el campo c1 de la clase sigue igual que estaba: size = 0;
El caso de c2 es totalmente diferente: se añade un valor a la lista, mediante un método propio, que se actualiza en el campo c2 de la clase. En este caso no hay reasignación de valor a la propia lista, por lo que los métodos de la misma que se usan dentro del método cambiaValores, se ejecutan en el campo de la clase a través del parámetro.
se da por correctísima la respuesta ;) Seguiremos. Una cosa, en el examen no se permite el uso de IDE's, lo que dificulta ciertas preguntas
Me parece un error que no se permita el uso de herramientas habituales, que los desarrolladores usan (o deberían usar) en su trabajo.
Viene a cuento una expresión que leí hace tiempo:
"Los programadores no somos compiladores" ;)
Creo que lo interesante es saber por qué suceden o no las cosas, no qué resultado sale o no por una consola, o por donde sea :)
En un examen de psicología me preguntaron: ¿dejarías usar una calculadora en un examen de matemáticas? Argumenta la respuesta. Pues algo parecido....
¿Dejarías usar Google en un examen de historia? Pregunto
Cuando estudié la carrera en la Universidad, dejaban usar cualquier cosa en los exámenes de todas las asignaturas, desde calculadoras, hasta apuntes personales, libros de texto... Sucedía en la Universidad Politécnica de Madrid, no vayas a pensar que era algún experimento extraterrestre ;D
¿Te puedes imaginar cómo eran los exámenes? ;)
Hay una diferencia entre "saber" de memoria ésto o aquello, a saber las razones por las que ésto es así, y aquello es asá.
El problema de fondo de la mayoría de exámenes es que insisten más en conocer de memoria determinados datos, que en saber razonar sobre ellos.
Por ese motivo, aquellos exámenes que realizaba, eran de una dureza inimaginable para la época: saber de memoria no ayudaba nada.
¿Qué año y qué quinta? Lo mío fue la UAM, quinta de 1982, año 2004 de licenciatura. Nada de apuntes en los exámenes, y prácticas mortales (implementación del protocolo TCP IP en C, por ejemplo).
Dispara ;)
¡Aparta que disparo! ;D
Soy algo más "viejo", de 1956 :) y terminé mis dolores de cabeza universitarios en 1979 (para empezar con otros mucho peores)
Espere sargento que me cuadro