Sintaxis de Java — ejercicios para escribir código que funciona a la primera

PorSergio Alejandro Medina Ospina
EjerciciosDesde ceroFP210 min de lectura

Ya escribiste tres programas en la práctica. Ahora toca resolver por tu cuenta. Tres ejercicios en tres niveles — todos con su enunciado, sus pistas y su solución comentada al final. El hilo conductor es el mismo en los tres: la estructura sale sola, los puntos y coma van donde tienen que ir, y printf formatea exactamente lo que quieres.

Como siempre: intenta resolverlo, usa la pista si llevas más de 10 minutos atascado, y compara con la solución comentada.

Sintaxis Java ejercicios — Nivel básico

Ejercicio 1 — Conversor de unidades

Escribe un programa completo en Java que pida al usuario una distancia en kilómetros y la convierta a metros, centímetros, millas y pies. Usa printf para mostrar todos los resultados alineados.

Salida esperada con 5.5 km:

=== CONVERSOR DE DISTANCIAS ===

Distancia en km: 5.5

--- Conversiones ---
Kilómetros:    5,50 km
Metros:     5500,00 m
Centímetros: 550000,00 cm
Millas:        3,42 mi
Pies:       18044,62 ft

Fórmulas:

metros      = km × 1000
centímetros = km × 100000
millas      = km / 1.60934
pies        = km × 3280.84

💡 Pistas:

  • Usa %10.2f para alinear los números a la derecha con 10 caracteres de ancho
  • Scanner sc = new Scanner(System.in) — importa java.util.Scanner al principio
  • El fichero debe llamarse Conversor.java y la clase Conversor

Sintaxis Java ejercicios — Nivel intermedio

Ejercicio 2 — Informe de notas

Escribe un programa que pida el nombre de un estudiante y sus notas en cinco asignaturas. El programa debe calcular la media, mostrar un informe formateado con todas las notas, e indicar cuántas asignaturas ha aprobado y cuántas ha suspendido.

Salida esperada:

=== INFORME DE NOTAS ===

Nombre del estudiante: Sergio Medina

Asignatura 1: FP2
Nota: 8.5

Asignatura 2: IC2
Nota: 7.0

Asignatura 3: Matemáticas
Nota: 4.5

Asignatura 4: Estadística
Nota: 6.0

Asignatura 5: Bases de Datos
Nota: 9.0

==============================
INFORME: Sergio Medina
==============================
FP2             8,50  Notable
IC2             7,00  Notable
Matemáticas     4,50  Suspenso
Estadística     6,00  Aprobado
Bases de Datos  9,00  Sobresaliente
------------------------------
Media:          7,00
Aprobadas:      4 / 5
Suspensos:      1 / 5
Estado:         APROBADO
==============================

💡 Pistas:

  • Pide cada asignatura con sc.nextLine() y cada nota con sc.nextDouble() + sc.nextLine() de limpieza
  • Para la clasificación usa if/else if en cadena: >= 9 Sobresaliente, >= 7 Notable, >= 5 Aprobado, resto Suspenso
  • %-15s en printf alinea texto a la izquierda con 15 caracteres de ancho
  • Cuenta aprobados con un contador que incrementas dentro del bucle de notas

Sintaxis Java ejercicios — Desafío final

Ejercicio 3 — Cajero automático

Escribe un programa que simule las operaciones básicas de un cajero automático. El usuario empieza con un saldo inicial que introduce él mismo, y puede realizar depósitos y retiradas. El programa muestra el saldo actualizado después de cada operación y un resumen final.

Salida esperada:

=== CAJERO AUTOMÁTICO ===

Saldo inicial (€): 1000

--- Operación 1 ---
Tipo (D=depósito / R=retirada): D
Cantidad (€): 250
✓ Depósito realizado
Saldo actual: 1250,00 €

--- Operación 2 ---
Tipo (D=depósito / R=retirada): R
Cantidad (€): 400
✓ Retirada realizada
Saldo actual: 850,00 €

--- Operación 3 ---
Tipo (D=depósito / R=retirada): R
Cantidad (€): 2000
✗ Saldo insuficiente (disponible: 850,00 €)
Saldo actual: 850,00 €

==============================
RESUMEN DE OPERACIONES
==============================
Saldo inicial:   1000,00 €
Total depositado:  250,00 €
Total retirado:    400,00 €
Saldo final:       850,00 €
Operaciones:       3
==============================

El programa realiza exactamente 3 operaciones (bucle for de 1 a 3). Si el tipo introducido no es D ni R, muestra un mensaje de error y no cuenta la operación como válida.

💡 Pistas:

  • Lee el tipo con sc.next().toUpperCase() para aceptar tanto d como D
  • Usa switch para distinguir entre "D", "R" y el caso por defecto (error)
  • Acumula totalDepositado y totalRetirado en variables separadas
  • Si la retirada supera el saldo: muestra el mensaje de error sin modificar el saldo

Soluciones comentadas

Solución Ejercicio 1

import java.util.Scanner;

public class Conversor {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.println("=== CONVERSOR DE DISTANCIAS ===");
        System.out.println();

        System.out.print("Distancia en km: ");
        double km = sc.nextDouble();

        double metros      = km * 1000;
        double centimetros = km * 100000;
        double millas      = km / 1.60934;
        double pies        = km * 3280.84;

        System.out.println();
        System.out.println("--- Conversiones ---");
        System.out.printf("Kilómetros:  %10.2f km%n", km);
        System.out.printf("Metros:      %10.2f m%n",  metros);
        System.out.printf("Centímetros: %10.2f cm%n", centimetros);
        System.out.printf("Millas:      %10.2f mi%n", millas);
        System.out.printf("Pies:        %10.2f ft%n", pies);

        sc.close();
    }
}

El especificador %10.2f le dice a printf que reserve 10 caracteres de ancho y muestre 2 decimales — los números quedan alineados a la derecha automáticamente. Si el número es más corto que 10 caracteres, printf añade espacios por la izquierda. Si quisieras alineación a la izquierda usarías %-10.2f.

Solución Ejercicio 2

import java.util.Scanner;

public class InformeNotas {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.println("=== INFORME DE NOTAS ===");
        System.out.println();

        System.out.print("Nombre del estudiante: ");
        String nombre = sc.nextLine();
        System.out.println();

        int numAsignaturas = 5;
        String[] asignaturas = new String[numAsignaturas];
        double[] notas       = new double[numAsignaturas];

        // Recoger datos
        for (int i = 0; i < numAsignaturas; i++) {
            System.out.printf("Asignatura %d: ", i + 1);
            asignaturas[i] = sc.nextLine();
            System.out.print("Nota: ");
            notas[i] = sc.nextDouble();
            sc.nextLine();    // limpiar salto de línea
            System.out.println();
        }

        // Calcular estadísticas
        double suma = 0;
        int aprobadas = 0;
        for (int i = 0; i < numAsignaturas; i++) {
            suma += notas[i];
            if (notas[i] >= 5.0) aprobadas++;
        }
        double media = suma / numAsignaturas;
        int suspensos = numAsignaturas - aprobadas;

        // Mostrar informe
        System.out.println("==============================");
        System.out.printf("INFORME: %s%n", nombre);
        System.out.println("==============================");

        for (int i = 0; i < numAsignaturas; i++) {
            String clasificacion;
            if (notas[i] >= 9.0)      clasificacion = "Sobresaliente";
            else if (notas[i] >= 7.0) clasificacion = "Notable";
            else if (notas[i] >= 5.0) clasificacion = "Aprobado";
            else                      clasificacion = "Suspenso";

            System.out.printf("%-15s %5.2f  %s%n",
                              asignaturas[i], notas[i], clasificacion);
        }

        System.out.println("------------------------------");
        System.out.printf("Media:        %5.2f%n", media);
        System.out.printf("Aprobadas:    %d / %d%n", aprobadas, numAsignaturas);
        System.out.printf("Suspensos:    %d / %d%n", suspensos, numAsignaturas);
        System.out.printf("Estado:       %s%n",
                          (media >= 5.0) ? "APROBADO" : "SUSPENSO");
        System.out.println("==============================");

        sc.close();
    }
}

Este ejercicio usa arrays por primera vez — String[] y double[]. No te preocupes si la sintaxis de arrays te suena nueva: en el artículo de arrays de Java lo cubrimos en detalle. Lo importante aquí es el patrón: primero un bucle para recoger los datos, luego otro para calcular, luego otro para mostrar.

Solución Ejercicio 3

import java.util.Scanner;

public class Cajero {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.println("=== CAJERO AUTOMÁTICO ===");
        System.out.println();

        System.out.print("Saldo inicial (€): ");
        double saldo = sc.nextDouble();
        sc.nextLine();

        double saldoInicial    = saldo;
        double totalDepositado = 0;
        double totalRetirado   = 0;
        int operaciones        = 3;

        for (int i = 1; i <= operaciones; i++) {
            System.out.printf("%n--- Operación %d ---%n", i);
            System.out.print("Tipo (D=depósito / R=retirada): ");
            String tipo = sc.next().toUpperCase();
            sc.nextLine();

            switch (tipo) {
                case "D":
                    System.out.print("Cantidad (€): ");
                    double deposito = sc.nextDouble();
                    sc.nextLine();
                    saldo += deposito;
                    totalDepositado += deposito;
                    System.out.println("✓ Depósito realizado");
                    break;

                case "R":
                    System.out.print("Cantidad (€): ");
                    double retirada = sc.nextDouble();
                    sc.nextLine();
                    if (retirada > saldo) {
                        System.out.printf(
                            "✗ Saldo insuficiente (disponible: %.2f €)%n", saldo);
                    } else {
                        saldo -= retirada;
                        totalRetirado += retirada;
                        System.out.println("✓ Retirada realizada");
                    }
                    break;

                default:
                    System.out.println("✗ Tipo no reconocido — use D o R");
                    i--;    // no contar esta operación
            }

            System.out.printf("Saldo actual: %.2f €%n", saldo);
        }

        // Resumen final
        System.out.println();
        System.out.println("==============================");
        System.out.println("RESUMEN DE OPERACIONES");
        System.out.println("==============================");
        System.out.printf("Saldo inicial:    %8.2f €%n", saldoInicial);
        System.out.printf("Total depositado: %8.2f €%n", totalDepositado);
        System.out.printf("Total retirado:   %8.2f €%n", totalRetirado);
        System.out.printf("Saldo final:      %8.2f €%n", saldo);
        System.out.printf("Operaciones:      %d%n", operaciones);
        System.out.println("==============================");

        sc.close();
    }
}

El i-- dentro del default es el truco que hace que una operación inválida no cuente — el bucle decrementa i antes de que el for lo incremente, efectivamente repitiendo esa iteración. En un programa real usarías un bucle while con validación, pero con la sintaxis que conoces hasta ahora este es el camino más directo.

Visualízalo con Python Tutor

Selecciona Java en el desplegable y pega en pythontutor.com:

public class Cajero {
    public static void main(String[] args) {
        double saldo = 1000;
        double totalDepositado = 0;
        double totalRetirado = 0;

        // Simulamos las operaciones sin Scanner
        // Operación 1: depósito de 250
        double deposito = 250;
        saldo += deposito;
        totalDepositado += deposito;

        // Operación 2: retirada de 400
        double retirada = 400;
        if (retirada <= saldo) {
            saldo -= retirada;
            totalRetirado += retirada;
        }

        // Operación 3: retirada fallida de 2000
        double retirada2 = 2000;
        if (retirada2 <= saldo) {
            saldo -= retirada2;
            totalRetirado += retirada2;
        } else {
            System.out.println("Saldo insuficiente");
        }

        System.out.printf("Saldo final: %.2f€%n", saldo);
        System.out.printf("Depositado:  %.2f€%n", totalDepositado);
        System.out.printf("Retirado:    %.2f€%n", totalRetirado);
    }
}

Ejecuta paso a paso y observa cómo saldo, totalDepositado y totalRetirado cambian en el marco de main con cada operación. En la tercera operación la condición retirada2 <= saldo falla — 2000 <= 850 es false — y el bloque else se ejecuta sin modificar saldo. Al final del programa las tres variables reflejan exactamente el estado del cajero.

Chuletario — sintaxis básica de Java

// ============================================
// CHULETARIO — Sintaxis básica Java
// Sergio Learns · sergiolearns.com
// ============================================

// ESTRUCTURA MÍNIMA — siempre esta forma
public class NombreClase {              // nombre = nombre del fichero .java
    public static void main(String[] args) {
        // tu código aquí
    }                                   // cierre del main
}                                       // cierre de la clase

// PALABRAS CLAVE EN main
// public  → accesible desde fuera
// static  → pertenece a la clase, no a un objeto
// void    → no devuelve nada
// main    → punto de entrada — nombre exacto obligatorio
// String[] args → argumentos de línea de comandos (requerido)

// SALIDA POR CONSOLA
System.out.println("texto");          // imprime + salto de línea
System.out.print("texto");            // imprime sin salto
System.out.printf("formato%n", val);  // formato estilo C

// ESPECIFICADORES DE FORMATO (printf)
%d    → int
%f    → double  (%.2f = 2 decimales)
%s    → String
%c    → char
%b    → boolean
%n    → salto de línea (mejor que \n en printf)
%%    → % literal
%10d  → alineado a la derecha, 10 chars
%-10d → alineado a la izquierda, 10 chars

// SECUENCIAS DE ESCAPE
\n → nueva línea    \t → tabulador
\" → comilla doble  \\ → barra invertida

// COMENTARIOS
// una línea
/* varias
   líneas */
/** javadoc — documenta clases y métodos */

// SCANNER — entrada del usuario
import java.util.Scanner;              // al principio del fichero
Scanner sc = new Scanner(System.in);  // crear el scanner

sc.nextLine()          // lee línea completa (String)
sc.nextInt()           // lee entero
sc.nextDouble()        // lee decimal
sc.next()              // lee una palabra
sc.next().charAt(0)    // lee un carácter
sc.next().toUpperCase()// lee y convierte a mayúsculas
sc.close()             // cerrar al terminar

// TRAMPA DEL nextLine() DESPUÉS DE nextInt()
int edad = sc.nextInt();
sc.nextLine();           // ← SIEMPRE — consume el \n sobrante
String nombre = sc.nextLine();  // ahora funciona correctamente

// REGLAS DE SINTAXIS
// 1. Cada instrucción termina en ;
// 2. { } delimitan bloques — la indentación es decorativa
// 3. Java distingue mayúsculas: String ≠ string, System ≠ system
// 4. El nombre del fichero debe coincidir con el nombre de la clase
// 5. Nunca ; después del paréntesis de for o if → bucle vacío

// ERRORES MÁS COMUNES
// Error: ';' expected          → falta punto y coma
// Error: cannot find symbol    → nombre mal escrito o tipo incorrecto
// Error: class X public        → fichero no se llama igual que la clase
// Error: reached end of file   → falta una llave de cierre }
// Resultado incorrecto sin error → ; después del for/if

// COMPILAR Y EJECUTAR (terminal)
// javac NombreClase.java   → genera NombreClase.class
// java NombreClase         → ejecuta el programa
// (en VS Code: botón ▶ encima del main)

Sigue aprendiendoTodos los artículos de Java

Estudiante de Ciencia e Ingeniería de Datos en la ULPGC. Explico lo
que aprendo en la carrera como me hubiera gustado que me lo explicaran
a mí: con sus dudas, sus errores y el camino hasta la solución.

Sigue aprendiendo

Un comentario

  1. Pingback: Sintaxis Java práctica: 3 programas reales desde cero

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *