Información
Programas en Java
En Python un programa mínimo está formado por una simple secuencia de una o más instrucciones. Por ejemplo, el típico ¡Hola, mundo! lo
escribiríamos en una única línea:
print("¡Hola, mundo!")
En Java un programa consta, como mínimo, de una clase que debe contener, al menos, un método de clase llamado main. El típico ¡Hola,
mundo! requiere de varias líneas:
class HolaMundo {
public static void main(String[] arg) {
[Link]("¡Hola, mundo!");
}
}
La clase puede llamarse como se quiera, pero el método principal ha de llamarse main y, además, debe:
Llevar el modificador public (las variables y métodos declarados en una clase pueden tener tres posibles modificadores de visibilidad:
public, protected y private).
Llevar el modificador static, que indica que es un método de clase, no un método de instancia.
Declarar un resultado de tipo void (en Java los métodos deben declarar en su cabecera, antes de su nombre, el tipo del resultado que
devolverán en una instrucción «return expresión;», pero el "tipo" void significa que el método no devuelve resultado, no siendo
obligatorio que haya instrucción de retorno, que en este caso sería simplemente «return;», la cual no devuelve nada, mientras que el
"equivalente" en Python devolvería el valor None).
Tener un parámetro (en el ejemplo llamado arg) de tipo String[], donde los corchetes indican referencia a un array (un tipo de
secuencia de tamaño fijo con índices, parecida a la tupla de Python) compuesto de elementos de tipo String (en Java todos los valores
de un array son del mismo tipo). Este parámetro sirve típicamente para pasarle indicaciones u opciones en forma de cortos argumentos
textuales al programa cuando lanzamos su ejecución, p.e. desde terminal.
En Java un programa está compuesto únicamente por un conjunto de clases distribuidas en varios ficheros cuyos nombres tienen que
coincidir con el de alguna de las clases que contengan, una de ellas principal conteniendo un método main como el visto anteriormente. En
una clase podemos declarar los atributos de datos estáticos (compartidos por todos los objetos de la clase) así como los atributos (no
estáticos) de instancia, en Java todos ellos presentes e inalterables en cada uno de los objetos de una misma clase; así como métodos
estáticos (que solo tendrán acceso a atributos estáticos) y no estáticos, de instancia, que permitirán acceder además a los atributos del objeto
sobre el que haya sido invocado en cada momento:
class MiClase {
private int n = 10; // Pre-inicializado (podría cambiarse en p.e. constructor)
double x; // Automáticamente pre-inicializado a 0.0
static String s = "Soy MiClase"; // Atributo de clase
// Constructor
MiClase(double v) {
this.x = v; // this. omisible: valía x = v;
}
// Método no estático (puede acceder al objeto this)
public double mult(int k) {
double result = k * x; // variable local result, valía también this.x
if (n > 0) n--; else return 0; // convierte int 0 al tipo resultado double
return result;
}
}
class Principal {
public static void main(String[] args) {
MiClase miObj = new MiClase(-1.04);
[Link](miObj.x + [Link](2)); // Muestra -3.12 (this=miObj en mult)
[Link](MiClase.s);
}
}
En el ejemplo anterior (que representa el contenido de un fichero de nombre [Link]) se han definido dos clases: MiClase (que se
usará para crear objetos de ese tipo) y Principal (cuyo main se ejecutará al lanzar el programa). Todos los objetos de MiClase tendrán dos
campos propios, n y x, este último inicializado (al no haberse especificado) automáticamente a su valor por defecto (0.0 para double). Se ha
especificado un constructor (podría haber ninguno o más de uno, distinguidos por sus parámetros), que ha de tener como nombre el de la
clase, con el que queremos que se inicialice x con un valor distinto del de por defecto. Se ha construido un método no estático, que nos
permite acceder a los atributos del objeto ya sea usando la refrencia automática this u omitiendo su uso si no resulta ambigüedad, como es
el caso; este método dispondrá de una variable local result durante su activación. El método main crea, usando new, un objeto de tipo
MiClase (inicializando su atributo de instancia x a -1.04), al cual referenciaremos con la variable local miObj, la cual nos permitirá desde
fuera de la clase acceder a los atributos y métodos de acceso no restringido del objeto, en este caso el atributo x, así como su método público
de instancia mult; asimismo vemos que es posible acceder al atributo estático de clase mediante el nombre de ésta (aunque también
podríamos haber usado miObj.s).
Pregunta 1
Correcta
Se puntúa 2,00 sobre 2,00
Complete el siguiente código:
class HolaMundo {
public static void main (String[] arg) {
[Link]("¡Hola, mundo!");
}
}
Información
Llaves, sangrado y punto y coma.
En Python una secuencia de instrucciones que pertenece al ámbito de una clase, función/método o estructura de control, debe sangrarse un
nivel adicional respecto a ésta:
for i in range(10):
print("¡Hola, mundo!")
En Java una secuencia de instrucciones que pertenece al ámbito de una clase, método o estructura de control, debe encerrarse entre llaves:
class HolaMundo {
public static void main(String[] arg) {
for(int i = 0; i < 10; i += 1) {
[Link]("¡Hola, mundo!");
}
}
}
También se sangra, pero esto se hace como convención de estilo para mejorar la legibilidad del programa.
Excepcionalmente, cuando la sentencia de control controla una única instrucción, se puede prescindir de las llaves, pero se aconseja no
hacerlo, ya que puede inducir a confusión o a cometer error en la lógica del código.
Nótese que en Java las instrucciones simples (que no se componen de otras instrucciones) han de acabar siempre con un punto y coma, que
convencionalmente se escribe sin espacio que lo preceda. En Python el punto y coma es opcional, y solo es obligatorio para separar varias
instrucciones simples en una misma línea, cosa que tampoco se aconseja.
Pregunta 2
Correcta
Se puntúa 1,00 sobre 1,00
Complete el siguiente código:
class HolaMundo {
public static void main(String[] arg) {
for(int i = 0; i < 10; i += 1) {
[Link]("¡Hola, mundo!") ;
}
}
}
Información
Salida por consola
En Python, para mostrar un mensaje en la consola se usa la función nativa print():
print("¡Hola mundo!")
Por omisión, la función print() inserta un salto de línea después del mensaje; esto se puede cambiar, especificando una string de
finalización. En el siguiente ejemplo, simplemente no se inserta nada detrás del primer mensaje (al pasarse la string vacía) y como resultado
los dos mensajes aparecerán seguidos en la misma línea:
print("¡Hola mundo!", end = "") # Se muestra:
print("Otro mensaje") # ¡Hola mundo!Otro mensaje
Si se pasan varios valores a mostrar a la función print(), serán automáticamente separados por un espacio, a menos que se especifique otro
separador:
print("¡Hola", "mundo!") # Se muestra: ¡Hola mundo!
print("¡Hola", "mundo!", sep = "-") # Se muestra: ¡Hola-mundo!(y el cursor pasará a la siguiente línea)
En Java, para mostrar un mensaje en la consola se puede usar el método [Link]():
class HolaMundo {
public static void main(String[] arg) {
[Link]("¡Hola mundo!");
}
}
El método [Link]() inserta un salto de línea detrás del mensaje, lo cual se puede evitar usando en su lugar el método
[Link](). En el siguiente ejemplo no hay salto de línea detrás del primer mensaje, por lo que un mensaje ulterior se mostraría
justo a continuación en la misma línea:
class HolaMundo {
public static void main(String[] arg) {
[Link]("¡Hola mundo!");
[Link]("Otro mensaje");
}
}
Los métodos [Link]() y [Link]() no admiten más de un parámetro, por lo que no ha lugar a separadores (de
todas formas, como en Python, podremos usar + para concatenar strings).
Pregunta 3
Correcta
Se puntúa 1,00 sobre 1,00
¿Qué opción en Java es equivalente a la siguiente sentencia en Python?
print("¡Hola mundo!", end = "")
Seleccione una:
[Link]("¡Hola mundo!", "");
[Link]("¡Hola mundo!");
[Link]("¡Hola mundo!");
Respuesta correcta
La respuesta correcta es: [Link]("¡Hola mundo!");
Información
Variables (locales a método/función)
En Python una variable se crea en el momento de asignarle un primer valor. El nombre de una variable es una secuencia de caracteres de
cualquier longitud formada por letras mayúsculas y minúsculas, dígitos y "guiones bajos" «_», con la restricción de que no pueden empezar
por un dígito. Por convención, se suelen usar letras minúsculas para formar palabras y guiones bajos para separar las palabras en caso de
nombres compuestos (convención lower_case_with_underscores):
int_var = 100
float_var = 100.80
str_var = "Hola"
El tipo de una variable viene determinado en cada momento por el del último valor que se le haya asignado. Aunque se le haya asignado
inicialmente un valor de un tipo, se le pueden asignar más tarde valores de tipos diferentes:
int_var = 3.14
Aparte de los atributos de datos de clases y objetos, que existen en Python y Java, las variables en Python pueden ser locales a una función o
método, o globales al módulo, mientras que en Java solo existen variables locales a métodos (siendo más precisos, locales a bloques,
delimitados por llaves «{···}»); no obstante p.e. un atributo de datos estático público puede servir de variable global al programa. En ambos
lenguajes, los parámetros de función/método son equivalentes a variables locales, solo que inicializadas con los valores de los argumentos en
el momento en la llamada.
En Java toda variable debe (al igual que los atributos de datos) ser declarada indicando su tipo además de su nombre, pudiendo además
asignársele un valor inicial, todo ello terminado en punto y coma. La presencia del tipo (con o sin asignación) indica que se trata de una
declaración:
int count = 100;
El nombre es una secuencia de caracteres de cualquier longitud que debe empezar con una letra, un guion bajo «_» o un símbolo de dólar
«$», seguido de cualquier combinación de letras, dígitos, guiones bajos y símbolos de dólar. Por convención, suelen empezar por una letra
minúscula, usar letras minúsculas para formar palabras, y, en el caso de nombres compuestos, poner la inicial de cada palabra, menos la
primera, en mayúscula (convención mixedCase):
float floatVar = 100.80f;
String strVar = "Hola";
Nótese la letra f tras el número en la asignación a la variable floatVar para indicar que es un valor de tipo float (por omisión, los literales
de números reales son de tipo double, que tiene mucha más precisión que el tipo float). El tipo declarado para una variable no se puede
cambiar, por lo que esta no puede recibir un valor de un tipo diferente (en algunos casos se produce una conversión automática del valor al
tipo de la variable).
Como se ha dicho, se puede declarar una variable sin asignarle un valor inicial,
int other;
pero (a diferencia de los atributos de datos) no recibiría automáticamente un valor definido. Por ello, el compilador de Java no va a permitir
ninguna instrucción que (ni siquiera aparentemente) pudiera usar una variable antes de haberle asignado explícitamente un valor; dando en
estos casos un error de compilación.
Por otro lado, si la declaración de la variable la antecedemos del modificador final, impedimos que posteriormente se le pueda cambiar el
valor asignado en esa única vez.
final int pi = 3.14;
En Java una variable se crea al ejecutarse su declaración, dejando de existir al salir del bloque que la contiene, por lo que solo podrá ser
accedida en dicho bloque (lo que incluye bloques internos al mismo). Por tanto, una variable sólo se ha de declarar la primera vez que aparece
en el código del bloque. En subsiguientes asignaciones del mismo bloque no se debe especificar el tipo, pues se vería como un intento de
declarar una nueva variable con el mismo nombre que una que ya existe, y se consideraría un error del código. No obstante, aunque poco
recomendable (y pudiéramos haberlo hecho por equivocación sin que el compilador se queje), es lícito declarar otra variable con el mismo
nombre en un bloque más interno, nombre que ocultará en este a partir de ahí la declarada en el bloque más externo, si bien se recuperará el
acceso al salir de dicho bloque interno. Por supuesto, podemos declarar en bloques que no estén contenidos uno en otro distintas variables
con el mismo nombre, aunque según el caso ello podría inducir a confusión.
Podemos decir que Python emplea ámbito dinámico (dynamic scope) para las variables, pues estas son accesibles dependiendo de cuándo se
crearon (y de cuándo fueron eliminadas con del, en su caso), mientras que Java emplea ámbito estático (static scope), pues las variables son
accesibles dependiendo de dónde están declaradas. El siguiente ejemplo ilustra la diferencia: aunque en Python es factible (la variable n sigue
existiendo al salir del bloque del if):
if b:
n = 5 # si se creara n
print(n) # *después* seguiría existiendo; si no, error al intentar acceder
si bien dará error en ejecución cuando b sea False, en Java un intento similar nos dará preventivamente un error en compilación (análisis del
fuente y, si todo va bien, generación del ejecutable) que nos impedirá lanzar la ejecución del programa:
if (b) {
int n = 5; // aun si se creara n
} // dejaría de existir
[Link](n); // *fuera* del bloque: error en compilación
En Java, como en Python, los datos de tipos no simples son accedidos mediante referencias. Así, cuando en Java declaramos que el tipo de
una variable es una clase, la variable solo podrá contener: o bien una referencia a un objeto de esa clase (o derivada de ella), o el valor null,
que es un valor lícito para una referencia, indicando que en este momento la variable no referencia a objeto. Tanto en Python como en Java
cuando deja de existir una variable que contiene una referencia a un objeto, este no dejará de existir si continúa siendo referenciado desde
alguna otra variable (ya sea directamente, o indirectamente a través de uno o más objetos).
Por último, en Java, al igual que en Python, el hecho de ejecutar una llamada no elimina las variables existentes en ese momento (se conservan
en la pila de ejecución); variables que volverán a ser accesibles por su nombre una vez se retorne. Cada llamada a función dará lugar a que
durante su ejecución esta cree nuevos ejemplares propios de variables (cada lenguaje según sus propios mecanismos, como hemos visto),
variables que tanto en Python como en Java dejarán de existir en todo caso al retornar la función/método.
Pregunta 4
Correcta
Se puntúa 1,00 sobre 1,00
En una declaración de variable en Java...
Seleccione una:
El nombre del tipo va después que el nombre de la variable y separado de éste por dos puntos
El nombre del tipo va antes que el nombre de la variable y separado de éste por espacios
El nombre del tipo va antes que el nombre de la variable y separado de éste por dos puntos
Respuesta correcta
La respuesta correcta es: El nombre del tipo va antes que el nombre de la variable y separado de éste por espacios
Información
Tipos de datos primitivos
Python integra una variedad de tipos de datos, entre los más simples están int (números enteros), float (números reales), bool (valores
True/False) y str (secuencias de caracteres), además del tipo NoneType, cuyo único valor es None.
Java integra los siguientes tipos denominados primitivos:
Cinco tipos de números enteros, de menor a mayor rango: byte, char, short, int y long (los tipos byte y char se usan también para
codificar caracteres individuales de texto).
Dos tipos de números reales: float y double
El tipo boolean (valores true/false)
Asimismo existe el valor que podemos expresar con el literal null, asignable a variables (o resultados) declaradas usando una clase como tipo
para indicar que no referencia a objeto alguno.
Por otro lado, usaremos el nombre void (que en realidad indica "no-tipo" y no tiene pues valor alguno asociado) para indicar que un método
no devuelve ningún valor.
class Main {
public static void main(String[] arg) {
char x = 'a';
x = 64;
[Link](x); // Muestra: @ (código ASCII 64)
}
}
El tipo String, que representa secuencias de caracteres, no se considera primitivo, pero recibe un tratamiento particularmente integrado.
Pregunta 5
Correcta
Se puntúa 1,00 sobre 1,00
En la siguiente lista de tipos de Java, marque los que representan números enteros.
Seleccione una o más de una:
byte
double
float
int
char
long
Respuesta correcta
Las respuestas correctas son: int, char, long, byte
Información
Valores y referencias
En la memoria dinámica (llamada así porque en ella los datos se crean y se eliminan durante la ejecución) que usa un programa distinguimos
dos zonas: el stack, o pila de ejecución, y el heap, o zona "desorganizada" (y que por ello requiere una gestión compleja). En la pila se ubican y
desubican, dinámica y organizadamente (por orden de creación/eliminación), datos de las distintas activaciones de subrutinas (esto es, para
cada llamada que aún no haya retornado), principalmente los ejemplares de variables locales que corresponden a cada activación. En el heap
se ubican y desubican dinámicamente objetos de datos de forma más arbitraria, conforme a detalles particulares de cada ejecución del
programa. La aparición y desaparición de las variables en la pila siguen un patrón claro de acuerdo con las llamadas y retornos, mientras que
el contenido del heap puede ser muy variable y en gran medida independiente del orden en que se producen llamadas y retornos.
Podemos distinguir entre dos categorías de datos según cómo se almacenan y se accede a ellos: valores y referencias. En el primer caso, las
variables contienen directamente los valores, y se almacenan típicamente en el stack; en el segundo, las variables contienen referencias
(esencialmente direcciones de memoria) a los objetos de datos (sus valores propiamente dichos), que se almacenan usualmente en el heap.
En Python, para todos los tipos de datos, los valores son objetos referenciados por variables que contienen sus direcciones de memoria, es
decir, son tipos referencia (incluso en teoría para los tipos simples, salvo que en cada asignación de uno de sus valores a una variable, esta
recibe una nueva referencia).
En Java los tipos de datos no primitivos se implementan igualmente como referencias a objetos (de alguna clase) en el heap, mientras que
para los tipos de datos primitivos se almacena directamente su valor. No obstante, a cada tipo primitivo se asocia una clase envoltorio
(wrapper) equivalente para cuando hace falta representar ese tipo de valores en formato objeto: Byte, Character, Short, Integer, Long,
Float, Double y Boolean.
Lo anterior permite comprender por qué en ambos lenguajes al asignar una variable con un tipo simple/primitivo a otra podamos luego
modificar una de ellas sin afectar a la otra, mientras que si lo que asignamos es una variable con un objeto, lo que se copia es la referencia, de
forma que ambas pasan a estar asociadas al mismo objeto, y modificarlo luego vía una de ellas afecta igualmente a la otra. De la misma forma,
en ambos lenguajes pasar un valor por parámetro o retornar un resultado es igualmente una manera de transmitir un valor simple/primitivo o
una referencia a objeto, según el tipo de dato.
El gráfico ilustra dos ejemplares de variables locales: una de tipo int (primitivo) y otra de tipo Integer (clase). La primera (a) almacena su
valor directamente en el stack, mientras que la segunda (b) almacena en el stack la dirección en el heap del objeto que representa su valor.
Naturalmente, en el heap habrá objetos que contengan a su vez referencias a objetos en el heap. En otros lenguajes es posible ubicar también
objetos en la pila.
Típicamente, como vemos, a las variables de la pila accedemos por su nombres (podemos usar nombres fijos para ellas gracias a que su
creación sigue un cierto patrón previsible), mientras que para acceder a los objetos del heap hemos de partir de las referencias en la pila,
denominándoseles a estas por tal motivo root set del heap.
Pregunta 6
Correcta
Se puntúa 1,00 sobre 1,00
En Java ¿cómo se llama el tipo wrapper del tipo int?
Respuesta: Integer
La respuesta correcta es: Integer
Información
Entrada básica de datos
En Python, para entrar datos a un programa, se usa la función input(), que lee strings y, en su caso, se hace a continuación una conversión
al tipo de datos que se espera:
number = int(input("Dame un número entero: "))
En Java hay diversas formas de entrar datos a un programa. Una de las más sencillas es usar un objeto de la clase Scanner:
import [Link];
class Input {
public static void main(String[] args) {
Scanner input = new Scanner([Link]);
[Link]("Dame un número entero: ");
int number = [Link]();
[Link]("Tecleaste " + number);
}
}
Básicamente se requieren 3 pasos:
1. Importar [Link]
2. Crear un objeto de tipo Scanner con [Link].
3. Usar el método adecuado de dicho objeto, dependiendo del tipo de datos que se quiere leer (.nextInt(), .nextFloat(),
.nextBoolean(), ...). Las strings se leen con el método .nextLine().
Esta diferencia de complejidad en la entrada por teclado y salida por terminal alfanumérica proviene de una diferencia en los objetivos
originales de diseño: Python más para interacción humana simple y Java menos orientado a ella o si acaso vía entorno gráfico y ratón. Ello
explica también que Java sea más exigente en los chequeos de compilación.