Saltar a contenido

UD1 — Ejercicios de afianzamiento

Resultado de Aprendizaje 1 — Reconoce la estructura de un programa informático, identificando y relacionando los elementos propios del lenguaje de programación utilizado.

IES Thiar · Curso 2026 - 2027

La siguiente colección de 45 ejercicios está organizada por secciones (de la 1 a la 9) y cubre los nueve criterios de evaluación del RA1.

Sección 1 — ¿Qué es programar? Java en el mundo real

CE 1.1 — Se han identificado los bloques que componen la estructura de un programa informático.

Ejercicio 1.1 — Receta de cocina → algoritmo

Enunciado: Tu abuela te dicta esta receta de tortilla:

"Pela 3 patatas. Córtalas en láminas finas. Pon aceite a fuego medio. Fríe las patatas 10 minutos. Bate 3 huevos. Mezcla. Cuaja 4 minutos por cada lado. Echa sal al gusto."

Se pide:

  1. Identifica cuál de los pasos no cumple la propiedad "definido" de un algoritmo y justifícalo.
  2. Reescribe ese paso de forma que sí cumpla la propiedad "definido".
  3. Indica cuál sería la "entrada" y cuál la "salida" del algoritmo.

Ejercicio 1.2 — JDK, JRE y JVM

Enunciado: Un compañero te dice: "Para ejecutar programas Java en mi equipo solo necesito instalar la JVM, no hace falta nada más".

Se pide: Explica si tiene razón o no, justificando qué componente(s) necesita realmente un usuario final que solo quiere ejecutar un programa Java y cuál necesita un programador.

Ejercicio 1.3 — ¿Compila o interpreta?

Enunciado: Java se describe a veces como "compilado" y a veces como "interpretado".

Se pide: Explica qué parte del proceso de Java es compilación y qué parte es interpretación. Nombra las herramientas y los ficheros intermedios.

Sección 2 — IntelliJ IDEA y Maven

CE 1.2 — Se han creado proyectos de desarrollo de aplicaciones. CE 1.3 — Se han utilizado entornos integrados de desarrollo.

Ejercicio 2.1 — Estructura de carpetas Maven

Enunciado: Tras crear un proyecto Maven en IntelliJ, aparecen estas carpetas en la raíz:

1
2
3
4
5
6
primerProyecto/
├── pom.xml
├── src/
│   ├── main/java/
│   └── test/java/
└── target/

Se pide: Indica, para cada una de las cinco rutas, qué contenido alberga y si deberías versionarla en Git.

Ejercicio 2.2 — Coordenadas Maven

Enunciado: Tu pom.xml declara:

1
2
3
<groupId>es.ies.ciclo</groupId>
<artifactId>calculadora-propina</artifactId>
<version>1.0-SNAPSHOT</version>

Se pide:

  1. Explica qué es cada una de las tres coordenadas.
  2. ¿Qué significa el sufijo -SNAPSHOT y por qué se usa durante el desarrollo?
  3. Indica el nombre del fichero .jar que se generará al ejecutar mvn package.

Ejercicio 2.3 — Ciclo de vida de Maven

Enunciado: Ejecutas mvn package por primera vez en un proyecto.

Se pide:

  1. Lista las fases del ciclo de vida default de Maven que se ejecutan antes de package.
  2. ¿Qué comando usarías para solo compilar, sin pasar pruebas ni empaquetar?
  3. ¿Qué comando usarías para eliminar los archivos generados y empezar limpio?

Sección 3 — Estructura de un programa Java

CE 1.1 — Se han identificado los bloques que componen la estructura de un programa informático. CE 1.9 — Se han introducido comentarios en el código.

Ejercicio 3.1 — Forma clásica vs Java 25

Enunciado: Tienes dos versiones del clásico "Hola, mundo":

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
// Versión A
public class HolaMundo {
    public static void main(String[] args) {
        System.out.println("Hola, mundo");
    }
}

// Versión B (Java 25)
void main() {
    IO.println("Hola, mundo");
}

Se pide:

  1. Indica qué bloques de la estructura de un programa Java están explícitos en A y implícitos en B.
  2. ¿En qué casos debes seguir usando la forma A (clásica)?
  3. ¿Desde qué JEP es estable la forma B?

Ejercicio 3.2 — Comentarios y Javadoc

Enunciado: El siguiente método público está documentado solo con un comentario de línea:

1
2
3
4
5
6
public class Calculadora {
    // calcula la propina
    public double propina(double importe, double porcentaje) {
        return importe * porcentaje / 100;
    }
}

Se pide:

  1. Reescribe el comentario como Javadoc correcto, indicando @param y @return.
  2. Explica por qué este cambio es importante para el mantenimiento.
  3. ¿Qué herramienta genera documentación HTML a partir de los comentarios Javadoc?

Ejercicio 3.3 — Convenciones de nomenclatura

Enunciado: Un alumno nuevo entrega este código:

1
2
3
4
5
6
7
public class calculadora_propina {
    public static double IVA = 0.21;
    int Importe_Total;
    public void CalculaPropina() {
        // ...
    }
}

Se pide: Aplica las convenciones de Oracle y reescribe cada identificador. Justifica cada cambio.

Sección 4 — Variables y tipos primitivos

CE 1.4 — Se han identificado los distintos tipos de variables y la utilidad específica de cada uno. CE 1.5 — Se ha modificado el código de un programa para crear y utilizar variables.

Ejercicio 4.1 — Declarar los 8 tipos primitivos

Enunciado: Declara una variable de cada uno de los 8 tipos primitivos de Java con un literal representativo: tu edad (byte), el año actual (short), la población de tu pueblo (int), la población mundial (long), el valor de PI en float (con sufijo f), PI más preciso en double, si eres mayor de edad (boolean) y tu inicial (char). Imprime cada una con IO.println.

Se pide: Escribe el programa completo en Java 25 (sin clase explícita).

Ejercicio 4.2 — var e inferencia de tipos

Enunciado: Predice el tipo inferido de cada var sin ejecutarlo. Luego compruébalo en IntelliJ pasando el ratón por encima.

1
2
3
4
5
6
7
8
var a = 42;
var b = 42L;
var c = 3.14;
var d = 3.14f;
var e = "hola";
var f = 'h';
var g = true;
var h = new java.util.Scanner(System.in);

Se pide: Rellena la tabla y justifica las decisiones del compilador.

Ejercicio 4.3 — Desbordamiento de int

Enunciado: Predice qué imprime el siguiente código sin ejecutarlo:

1
2
3
int x = 1_000_000_000;
x = x * 3;
System.out.println(x);

Se pide: Explica el resultado y propón una solución.

Ejercicio 4.4 — Ámbito de variables

Enunciado: El siguiente código no compila. Explica por qué y arréglalo.

1
2
3
4
5
6
void main() {
    if (true) {
        int x = 10;
    }
    System.out.println(x);   // error
}

Se pide: Identifica el concepto relacionado y reescribe el código.

Sección 5 — Operadores

CE 1.7 — Se han clasificado, reconocido y utilizado en expresiones los operadores del lenguaje.

Ejercicio 5.1 — = vs ==

Enunciado: ¿Qué hace cada una de estas líneas? ¿Cuáles compilan? ¿Cuáles son errores lógicos?

1
2
3
4
5
int a = 5;
if (a = 10) { /* ... */ }     // (1)
if (a == 10) { /* ... */ }   // (2)
boolean b = false;
if (b = true) { /* ... */ }  // (3)

Se pide: Analiza las tres líneas y comenta los errores.

Ejercicio 5.2 — División entera

Enunciado: Predice el resultado de cada println:

1
2
3
4
5
System.out.println(7 / 2);       // (1)
System.out.println(7 / 2.0);     // (2)
System.out.println(7.0 / 2);     // (3)
System.out.println(7 % 2);      // (4)
System.out.println(-7 / 2);     // (5)

Se pide: Indica cada resultado y justifica.

Ejercicio 5.3 — ++i vs i++

Enunciado: Predice los valores finales sin ejecutar:

1
2
3
4
int i = 5;
int a = i++;     // post-incremento
int b = ++i;     // pre-incremento
int c = i;       // asignación simple

Se pide: Indica los valores de i, a, b, c al final.

Ejercicio 5.4 — Cortocircuito

Enunciado: ¿Lanza NullPointerException el siguiente código?

1
2
3
String s = null;
boolean r = (s != null) && (s.length() > 0);
System.out.println(r);

Se pide: Explica el comportamiento y el concepto de cortocircuito.

Ejercicio 5.5 — De Morgan

Enunciado: Reescribe la siguiente condición sin usar ! externo:

1
boolean r = !(a > b && c < d);

Se pide: Aplica las leyes de De Morgan y simplifica.

Ejercicio 5.6 — Concatenación y tipos

Enunciado: Predice qué imprime cada línea:

1
2
3
4
System.out.println(1 + 2 + "3");      // (1)
System.out.println("" + 1 + 2);      // (2)
System.out.println("1" + 2 + 3);     // (3)
System.out.println(1 + "" + 2 + 3);  // (4)

Se pide: Indica cada resultado y explica el orden de evaluación.

Ejercicio 5.7 — Comparación de decimales

Enunciado: Explica por qué 0.1 + 0.2 == 0.3 da false en Java. Escribe una comparación correcta usando un épsilon.

Se pide: Justifica el problema y propón la solución.

Sección 6 — Constantes y literales

CE 1.6 — Se han creado y utilizado constantes y literales.

Ejercicio 6.1 — Refactorización de magic numbers

Enunciado: El siguiente código contiene tres magic numbers. Refactóralo declarando constantes con static final y UPPER_SNAKE_CASE.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
public class Circulo {
    public double area(double radio) {
        return 3.14159 * radio * radio;
    }
    public double perimetro(double radio) {
        return 2 * 3.14159 * radio;
    }
    public double areaSector(double radio, double angulo) {
        return 0.5 * 3.14159 * radio * radio * angulo / 360.0;
    }
}

Se pide: Identifica los magic numbers y reescribe el código.

Ejercicio 6.2 — final en referencias

Enunciado: Predice qué pasa sin ejecutarlo y comprueba después:

1
2
3
4
5
6
import java.util.ArrayList;
import java.util.List;

final List<String> lista = new ArrayList<>();
lista.add("hola");          // (1)
lista = new ArrayList<>();  // (2)

Se pide: Indica qué líneas compilan y cuáles no, y justifica.

Ejercicio 6.3 — Enumeraciones básicas

Enunciado: Declara un enum llamado EstadoPedido con los valores PENDIENTE, PAGADO, ENVIADO, ENTREGADO, CANCELADO. Escribe un programa que recorra todos los valores e imprima su nombre y posición.

Se pide: Escribe el código completo.

Sección 7 — El tipo String y texto multilínea

CE 1.5 — Se ha modificado el código de un programa para crear y utilizar variables (en este caso, de tipo String).

Ejercicio 7.1 — Inmutabilidad de String

Enunciado: El siguiente código pretende "mayusculizar" la variable nombre. No funciona. Explícalo y arréglalo.

1
2
3
String nombre = "ana";
nombre.toUpperCase();
System.out.println(nombre);

Se pide: Identifica el problema y reescribe el código.

Ejercicio 7.2 — == vs .equals()

Enunciado: Predice cuáles de estas comparaciones dan true sin ejecutarlas y comprueba después:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
String a = "hola";
String b = "hola";
String c = new String("hola");
String d = "ho" + "la";

System.out.println(a == b);          // (1)
System.out.println(a == c);          // (2)
System.out.println(a.equals(c));     // (3)
System.out.println(a == d);          // (4)
System.out.println(a.equals(d));     // (5)

Se pide: Indica cada resultado y justifica.

Ejercicio 7.3 — Text blocks

Enunciado: Convierte este código horroroso a un text block:

1
2
3
4
String recibo = "-----------------------------\n"
        + "Importe:        " + importe + " €\n"
        + "Propina (" + porcentaje + "%):  " + propina + " €\n"
        + "-----------------------------\n";

Se pide: Reescríbelo con """...""" y .formatted.

Ejercicio 7.4 — Métodos de String

Enunciado: Dado String s = " Hola, Mundo ";, escribe una sola línea que devuelva "MUNDO" (la segunda palabra, en mayúsculas, sin espacios). Pista: combina strip, toUpperCase, substring, indexOf.

Se pide: Propón una solución y explícala paso a paso.

Ejercicio 7.5 — Null-safety con String

Enunciado: El siguiente código puede lanzar NullPointerException. Modifícalo usando Objects.equals para que sea seguro.

1
2
3
String a = null;
String b = "hola";
boolean r = a.equals(b);   // NPE

Se pide: Reescribe el código usando Objects.equals y explica por qué es null-safe.

Sección 8 — Conversión de tipos

CE 1.8 — Se ha comprobado el funcionamiento de las conversiones de tipos explícitas e implícitas.

Ejercicio 8.1 — Widening

Enunciado: Predice si cada asignación compila y por qué:

1
2
3
4
5
int i = 5;
long l = i;          // (1)
double d = l;          // (2)
float f = l;           // (3)
byte b = i;            // (4)

Se pide: Indica cuáles compilan y por qué.

Ejercicio 8.2 — Casting explícito

Enunciado: Predice el resultado de cada println:

1
2
3
4
5
System.out.println((int) 3.7);              // (1)
System.out.println((int) -3.7);             // (2)
System.out.println((int) 3.5);              // (3)
System.out.println((int) Math.round(3.5));  // (4)
System.out.println((int) (5 / 2.0));         // (5)

Se pide: Indica cada resultado y explica el truncamiento.

Ejercicio 8.3 — Desbordamiento al hacer cast

Enunciado: Predice el resultado sin ejecutarlo y comprueba después:

1
2
int x = (int) 5_000_000_000L;
System.out.println(x);

Se pide: Explica el valor obtenido y propón una forma segura de hacer el cast.

Ejercicio 8.4 — Boolean.parseBoolean

Enunciado: Predice el resultado de cada parseBoolean:

1
2
3
4
5
6
System.out.println(Boolean.parseBoolean("true"));    // (1)
System.out.println(Boolean.parseBoolean("TRUE"));    // (2)
System.out.println(Boolean.parseBoolean("1"));       // (3)
System.out.println(Boolean.parseBoolean("false"));  // (4)
System.out.println(Boolean.parseBoolean("hola"));   // (5)
System.out.println(Boolean.parseBoolean(""));       // (6)

Se pide: Indica cada resultado y explica el comportamiento.

Ejercicio 8.5 — Conversión a String

Enunciado: Escribe dos formas distintas de convertir el entero 42 a String y explica cuál es null-safe.

Se pide: Propón las dos formas y razona la respuesta.

Ejercicio 8.6 — Parseo de entrada

Enunciado: El usuario escribe "3,14" (con coma decimal) en un campo de texto. Necesitas convertirlo a double.

Se pide: Escribe la línea de código Java que realiza la conversión de forma segura y explica por qué es necesaria.

Sección 9 — Entrada de información: java.lang.IO

CE 1.5 — Se ha modificado el código de un programa para crear y utilizar variables (leyéndolas desde la entrada estándar).

Ejercicio 9.1 — Saludar

Enunciado: Escribe un programa que pida al usuario su nombre y su ciudad y muestre por pantalla "Hola, [nombre] de [ciudad]".

Se pide: Usa IO.readln con prompt. No hace falta validar la entrada.

Ejercicio 9.2 — Área de un rectángulo

Enunciado: Pide la base y la altura de un rectángulo (como double), calcula el área y muéstrala con dos decimales usando formatted. Recuerda el .replace(",", ".") si el usuario escribe con coma.

Se pide: Escribe el programa completo en Java 25.

Ejercicio 9.3 — Conversor de temperatura

Enunciado: Pide una temperatura en grados Celsius y muéstrala en Fahrenheit. La fórmula es F = C × 9/5 + 32. Maneja la coma decimal del input.

Se pide: Escribe el programa.

Ejercicio 9.4 — Media de tres notas

Enunciado: Pide tres notas (enteros de 0 a 10), calcula la media y muestra "Aprobado" si es ≥ 5 o "Suspenso" si no, usando el operador ternario. No valides el rango (camino feliz).

Se pide: Usa Integer.parseInt para convertir la entrada. Usa el operador ternario ?: para mostrar el resultado.

Ejercicio 9.5 — Scanner vs IO.readln

Enunciado: Reescribe el ejercicio 9.2 usando Scanner.nextDouble() con useLocale(Locale.US).

Se pide: Compara cuál de las dos soluciones te resulta más cómoda y por qué.

Repaso integrador — Ejercicio final

CE 1.1, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9 (transversal).

Ejercicio final — Calculadora de propina completa

Enunciado: Escribe un programa Java 25 (sin clase explícita, con void main()) que implemente una calculadora de propina completa. El programa debe:

  1. Declarar dos constantes de clase: IVA_GENERAL (0.21) y PORCENTAJE_PROPINA_DEFECTO (10.0).
  2. Pedir al usuario por teclado, usando IO.readln:
  3. El importe de la cuenta (en euros, con decimales).
  4. El porcentaje de propina deseado (si el usuario pulsa Enter sin escribir nada, se usa PORCENTAJE_PROPINA_DEFECTO).
  5. Calcular:
  6. La propina = importe × porcentaje / 100.
  7. El total con IVA = importe × (1 + IVA_GENERAL).
  8. El total a pagar = total con IVA + propina.
  9. Mostrar por pantalla un recibo formateado con text block y .formatted, con dos decimales para los importes y un decimal para el porcentaje.
  10. El código debe estar correctamente comentado (Javadoc en main, comentarios // donde aporten información) y usar identificadores claros según las convenciones de Oracle.

Se pide: Escribe el programa completo y la salida esperada para un importe de 48,50 y propina por defecto.

Resumen final

Has completado 45 ejercicios que cubren los nueve criterios de evaluación del RA1. Si has sido capaz de resolverlos dominas:

  • CE 1.1: estructura de un programa Java (clase, main, sentencias, JEP 512).
  • CE 1.2: proyectos Maven (coordenadas, pom.xml, ciclo de vida).
  • CE 1.3: IntelliJ IDEA (estructura, convenciones, atajos).
  • CE 1.4: los 8 tipos primitivos y var.
  • CE 1.5: declaración y uso de variables (String, tipos primitivos, IO.readln).
  • CE 1.6: constantes (final, static final) y literales.
  • CE 1.7: operadores aritméticos, relacionales, lógicos, ternarios, de asignación.
  • CE 1.8: conversiones implícitas y explícitas, parseo de cadenas.
  • CE 1.9: comentarios (//, /* */, /** */ Javadoc) y buenas prácticas.

Si te han costado algunos, vuelve a la sección correspondiente del material y repasa. La práctica es la mejor forma de afianzar los fundamentos.