Autor: fernandoruizrico

Introducción

Si has llegado hasta aquí, ya sabes cómo crear tus propias clases, agrupar objetos y organizar tu código de maravilla. ¡Enhorabuena! Pero hay un enemigo invisible que acecha a casi todos los programadores cuando empiezan a desarrollar aplicaciones reales: la ausencia de datos o, como se le conoce técnicamente, el valor null.

En lenguajes más antiguos como Java, si intentas acceder a una propiedad de un objeto (por ejemplo, el correo electrónico de un usuario) y resulta que ese usuario no existe en la base de datos (es null), tu programa se cuelga abruptamente lanzando un fatídico NullPointerException. Es un fallo tan común, molesto y destructivo que a su propio inventor le gusta llamarlo «el error del billón de dólares».

Aquí es donde Kotlin brilla con luz propia. Para evitar que tu aplicación explote en las manos de tus usuarios, Kotlin implementa en su núcleo la seguridad contra nulos (Null Safety). Este sistema es como un escudo protector que detecta los posibles problemas mientras escribes tu código (en tiempo de compilación), obligándote a manejarlos de forma elegante mucho antes de que el código llegue a ejecutarse. ¡Vamos a descubrir su magia!

¿Qué son los tipos anulables (Nullable types)?

Por defecto, en Kotlin está estrictamente prohibido que una variable normal guarde un valor nulo. El compilador, simplemente, no te dejará hacerlo. Y esto es fantástico para dormir tranquilos.

Sin embargo, a veces es necesario representar que algo «falta», está vacío o aún no se ha configurado (como un segundo apellido opcional en un formulario). Para decirle a Kotlin que una variable sí tiene permiso para ser nula, debes declarar un tipo anulable añadiendo explícitamente el símbolo de interrogación ? justo después de su tipo de dato.

fun main() {
    // neverNull es un String normal, jamás aceptará nulos
    var neverNull: String = "Esto no puede ser nulo"
    
    // Si intentas hacer esto, el compilador te lanzará un error
    // neverNull = null

    // nullable es un String? (String anulable)
    var nullable: String? = "Aquí puedes guardar texto"
    
    // Esto es perfectamente válido
    nullable = null
}

Si intentas acceder directamente a una propiedad de una variable que podría ser nula, por ejemplo nullable.length, Kotlin te detendrá y te dará un error. ¿Por qué? Porque podría ser peligroso. Necesitas utilizar herramientas seguras.

Comprobación tradicional de nulos

La forma más básica de manejar un tipo anulable es usar una clásica estructura condicional if para asegurarte de que hay algo ahí dentro antes de usarlo.

fun describirTexto(texto: String?): String {
    // Kotlin comprueba primero que la variable no esté vacía
    if (texto != null && texto.length > 0) {
        return "El texto tiene ${texto.length} caracteres"
    } else {
        return "El texto está vacío o es nulo"
    }
}

El dato: Cuando realizas una comprobación manual como if (texto != null), el compilador de Kotlin es lo bastante inteligente como para aplicar un «smart cast» (conversión inteligente). Dentro de ese bloque if, Kotlin tratará automáticamente a tu variable anulable como si fuera totalmente segura, permitiéndote acceder a .length sin que te salte ningún error.

Llamadas seguras (?.)

Si tuviéramos que escribir un if cada vez que usamos algo que puede ser nulo, nuestro código sería un tostón larguísimo y muy difícil de leer. Afortunadamente, a Kotlin le encanta el código conciso.

Para acceder de forma rápida a las propiedades de un objeto que podría contener un valor nulo, utilizamos el operador de llamada segura ?.

Este operador lo hace todo por detrás: intenta leer la propiedad que le pides, y si resulta que el objeto original es nulo, en lugar de crashear tu aplicación, simplemente devuelve null de forma pacífica y sigue ejecutando el resto de tu código.

fun longitudDelTexto(texto: String?): Int? = texto?.length

fun main() {
    val miTextoNulo: String? = null
    println(longitudDelTexto(miTextoNulo)) 
    // Salida por consola: null
}

Una de las características más potentes de este operador es que las llamadas seguras se pueden encadenar. Si quieres acceder a un dato que se encuentra escondido muy profundamente en tu estructura de clases, puedes hacerlo así:

val paisDelJefe = empleado.empresa?.departamento?.jefe?.pais

Si el empleado no tiene empresa, o la empresa no tiene departamento, el viaje se detiene ahí mismo y la variable paisDelJefe guardará simplemente un null, sin pánicos ni errores de ejecución.

El operador Elvis (?:)

Muchas veces no queremos que el resultado final de nuestra llamada sea null. Es muy común querer proporcionar un valor por defecto si las cosas fallan. Para esto tenemos al espectacular operador Elvis ?: (se llama así porque si giras la cabeza a la izquierda, el símbolo recuerda al mítico tupé de Elvis Presley).

La estructura es muy simple: escribes a la izquierda del Elvis lo que quieres intentar leer, y a la derecha escribes el valor de respaldo que quieres devolver en caso de que lo de la izquierda haya resultado ser nulo.

fun main() {
    val texto: String? = null
    
    // Si texto?.length es nulo, usamos el 0 como comodín
    val longitud = texto?.length ?: 0
    
    println("La longitud es: $longitud")
    // Salida por consola: La longitud es: 0
}

La ejecución condicionada con let (?.let)

Una herramienta de uso diario muy habitual en Kotlin. ¿Y si quieres ejecutar un bloque entero de código únicamente si tu variable no es nula? Combinando la llamada segura ?. con la función let, construimos un entorno hermético y totalmente blindado.

fun main() {
    val correo: String? = "[email protected]"
    
    // Todo lo que hay dentro de las llaves solo se ejecuta si hay correo
    correo?.let { correoSeguro ->
        println("Enviando mensaje de bienvenida a $correoSeguro")
    }
}

La regla de oro: Acostúmbrate a usar siempre llamadas seguras ?. o el operador Elvis ?: para lidiar con tipos anulables. Únicamente hay un escenario en el que podrías forzar la máquina: usando el operador de aserción !! (la doble exclamación). Este operador fuerza la lectura de la variable ignorando la seguridad; si el valor resulta ser nulo, tu aplicación se cerrará inmediatamente. Úsalo solo si pondrías la mano en el fuego de que ese dato existe, o mejor aún, ¡evítalo a toda costa en tu día a día!

Ejercicios

Aquí tienes varios ejercicios de menos a más dificultad (el primero es una traducción adaptada de la documentación oficial de Kotlin y el resto son extras para asentar los conceptos que hemos ampliado). Abre tu Kotlin Playground y vamos a mancharnos las manos.

El empleado sin sueldo

Tienes la función employeeById que te da acceso a la base de datos de los empleados de una compañía según su ID. Por desgracia, la función devuelve un tipo Employee?, por lo que el resultado puede ser null si el empleado no existe. Tu objetivo es escribir el código de la función salaryById(id: Int) para que devuelva el salario del empleado si lo encuentra, o el valor 0 si el empleado ha desaparecido de los registros.

data class Employee(val name: String, var salary: Int)

fun employeeById(id: Int) = when(id) {
    1 -> Employee("Mary", 20)
    2 -> null
    3 -> Employee("John", 21)
    4 -> Employee("Ann", 23)
    else -> null
}

fun salaryById(id: Int): Int {
    // Escribe tu código aquí (Pista: usa llamada segura + Elvis)
}

fun main() {
    // Esto debería imprimir la suma total de los salarios existentes (64)
    println((1..5).sumOf { id -> salaryById(id) })
}

El formulario de contacto

Imagina que estás programando un formulario de registro. Crea una función llamada obtenerLongitudTelefono que reciba un número de teléfono (String?) que puede ser nulo. Utiliza una llamada segura y el operador Elvis en una sola línea para devolver el número de caracteres del teléfono, o 0 si el usuario decidió no teclear ninguno.

// Escribe aquí tu función obtenerLongitudTelefono

fun main() {
    val telefono1: String? = "654321987"
    val telefono2: String? = null

    println(obtenerLongitudTelefono(telefono1)) // Debería imprimir 9
    println(obtenerLongitudTelefono(telefono2)) // Debería imprimir 0
}

La cadena de mando

A veces los objetos contienen a otros objetos que, a su vez, también pueden ser nulos. Declara tres data classes:

1. Jefe (con una propiedad nombre de tipo String).
2. Departamento (con una propiedad jefe de tipo Jefe?).
3. Empresa (con una propiedad departamento de tipo Departamento?).

Luego, en tu función main(), crea una instancia de Empresa donde el departamento sea null. Usando llamadas seguras encadenadas, intenta recuperar el nombre del jefe. Si en algún momento la cadena se rompe por un nulo, haz que se asigne automáticamente el texto «Sin jefe asignado» usando el operador Elvis. Imprime el resultado final.

// Escribe aquí tus clases

fun main() {
    // 1. Crea una Empresa con departamento = null
    // 2. Encadena las llamadas e imprime el resultado
}

El sistema de alertas

Tienes un mensaje de alerta opcional. Usando la llamada segura ?. junto a la función let, haz que el sistema imprima en mayúsculas (usando el método .uppercase()) el texto de la alerta solo y exclusivamente si este no es nulo.

fun main() {
    val alertaActiva: String? = "Peligro de sobrecalentamiento en el núcleo"
    val alertaApagada: String? = null

    // Escribe aquí tu código usando let para procesar alertaActiva
    
    // Y luego repite exactamente lo mismo para alertaApagada 
    // (este segundo bloque no debería imprimir nada por consola)
}

Soluciones a los ejercicios

No hagas trampas. Échale un vistazo a las soluciones únicamente cuando te hayas peleado un buen rato con tu editor de código y el compilador te haya gritado un par de veces.

El empleado sin sueldo

data class Employee(val name: String, var salary: Int)

fun employeeById(id: Int) = when(id) {
    1 -> Employee("Mary", 20)
    2 -> null
    3 -> Employee("John", 21)
    4 -> Employee("Ann", 23)
    else -> null
}

// Usamos la llamada segura '?.salary' acoplada al valor de respaldo '?: 0'
fun salaryById(id: Int): Int = employeeById(id)?.salary ?: 0

fun main() {
    println((1..5).sumOf { id -> salaryById(id) })
}

El formulario de contacto

fun obtenerLongitudTelefono(telefono: String?): Int {
    return telefono?.length ?: 0
}

fun main() {
    val telefono1: String? = "654321987"
    val telefono2: String? = null

    println(obtenerLongitudTelefono(telefono1)) 
    println(obtenerLongitudTelefono(telefono2)) 
}

La cadena de mando

data class Jefe(val nombre: String)
data class Departamento(val jefe: Jefe?)
data class Empresa(val departamento: Departamento?)

fun main() {
    // Creamos nuestra empresa pasándole un departamento nulo
    val miEmpresa = Empresa(departamento = null)

    // Encadenamos con '?.'. Como el departamento es null, salta directamente al Elvis
    val nombreDelJefe = miEmpresa.departamento?.jefe?.nombre ?: "Sin jefe asignado"
    
    println(nombreDelJefe)
}

El sistema de alertas

fun main() {
    val alertaActiva: String? = "Peligro de sobrecalentamiento en el núcleo"
    val alertaApagada: String? = null

    alertaActiva?.let { mensaje ->
        println(mensaje.uppercase())
    }

    // Como esta variable es null, la ejecución ignorará todo el bloque let
    alertaApagada?.let { mensaje ->
        println(mensaje.uppercase())
    }
}

Introducción

Si has llegado hasta aquí, ya sabes cómo crear variables, manejar distintos tipos de datos, organizar información en colecciones y controlar el flujo de tu programa con condicionales y bucles. ¡Enhorabuena! Tienes las bases. Pero ahora toca dar el siguiente paso lógico en la programación: las funciones.

Imagina que en tu código tienes que hacer un cálculo complejo o mostrar un mensaje específico docenas de veces a lo largo del programa. ¿Vas a copiar y pegar el mismo bloque de código una y otra vez? Para eso están las funciones. En esta unidad, vamos a ver cómo Kotlin hace que declarar y usar funciones sea un proceso muy limpio, adentrándonos por último en el fascinante mundo de las expresiones lambda, una de las características más apreciadas por los desarrolladores modernos.

¿Qué son las funciones y cómo se declaran?

En Kotlin, puedes declarar tus propias funciones utilizando la palabra reservada fun (muy apropiado, ¿verdad? ¡Programar en Kotlin es divertido!). Una función no es más que un bloque de código al que le damos un nombre y que realiza una tarea concreta.

fun sumar(x: Int, y: Int): Int {
    return x + y
}

fun main() {
    println(sumar(1, 2))
    // Salida: 3
}

Analizando el código paso a paso:

• fun: La palabra clave mágica para decirle a Kotlin que vamos a crear una función.
• Los parámetros: Se escriben siempre entre paréntesis (). Cada parámetro debe tener un tipo de dato explícito (en este caso x e y son de tipo Int), y si hay varios, se separan por comas. Son los datos que la función necesita para poder trabajar.
• El tipo de retorno: Después de los paréntesis de los parámetros y separado por dos puntos :, indicamos qué tipo de dato va a devolver la función como resultado final. En este caso, devolverá un número entero (Int).
• El cuerpo de la función: Es todo lo que va dentro de las llaves {}.
• return: Usamos esta palabra para escupir o devolver el resultado de nuestro cálculo y dar por terminada la ejecución de la función.

El dato: Las convenciones de código oficiales de Kotlin recomiendan nombrar las funciones empezando con minúscula y usando camelCase (por ejemplo, calcularPrecioTotal, imprimirUsuario), sin usar guiones bajos.

Parámetros nombrados

A veces, cuando llamas a una función que tiene muchísimos parámetros, el código puede volverse un poco lioso a simple vista. ¿Qué era ese true o ese 5 que le pasábamos a la función en la tercera posición? Kotlin nos permite usar parámetros nombrados.

Si incluyes el nombre del parámetro explícitamente al llamar a la función, no solo haces que tu código sea muchísimo más fácil de leer, sino que además puedes poner los parámetros en el orden que quieras.

fun imprimirMensaje(mensaje: String, prefijo: String) {
    println("[$prefijo] $mensaje")
}

fun main() {
    // Usamos argumentos nombrados y además invertimos el orden
    imprimirMensaje(prefijo = "LOG", mensaje = "Sistema iniciado correctamente")
    // Resultado: [LOG] Sistema iniciado correctamente
}

Valores por defecto

En lenguajes más antiguos, si a veces querías llamar a una función pasándole tres parámetros y otras veces solo dos, tenías que crear varias versiones de la misma función (esto se conoce como sobrecarga de métodos).

En Kotlin, te ahorras todo ese trabajo. Puedes definir valores por defecto para los parámetros utilizando el operador de asignación =. Si al llamar a la función omites ese parámetro, Kotlin utilizará automáticamente el valor por defecto que configuraste.

fun imprimirMensaje(mensaje: String, prefijo: String = "INFO") {
    println("[$prefijo] $mensaje")
}

fun main() {
    // Llamamos a la función pasándole ambos parámetros
    imprimirMensaje("Usuario conectado", "LOG") 
    // Resultado: [LOG] Usuario conectado
    
    // Llamamos a la función pasándole SOLO el mensaje. ¡Usa el prefijo por defecto!
    imprimirMensaje("El proceso ha finalizado") 
    // Resultado: [INFO] El proceso ha finalizado
}

La regla de oro: Puedes saltarte parámetros concretos que tengan valores por defecto, pero si omites uno y quieres pasar el siguiente, tendrás que usar obligatoriamente parámetros nombrados para los que pongas a continuación.

Funciones que no devuelven nada

Si tu función simplemente realiza una acción (como imprimir un texto por la consola, reproducir un sonido o guardar un dato en la base de datos) pero no necesita devolverte ningún resultado matemático o lógico útil, su tipo de retorno en Kotlin es Unit (el equivalente al void en Java o C).

La maravilla de Kotlin es que no hace falta que escribas Unit ni que pongas un return. El compilador ya lo sabe.

fun saludar(nombre: String) {
    println("¡Hola, $nombre!")
    // Escribir `: Unit` arriba junto a los paréntesis o `return Unit` aquí abajo es totalmente opcional (y casi nadie lo hace).
}

Funciones de una sola expresión

Para hacer tu código aún más conciso y espectacular, si tu función consta de una única instrucción que devuelve un valor, puedes ahorrarte de un plumazo las llaves {} y la palabra return. Solo tienes que usar el signo igual =.

Tomemos la función sumar del principio:

fun sumar(x: Int, y: Int): Int {
    return x + y
}

Se puede transformar en esta maravilla de una sola línea:

fun sumar(x: Int, y: Int) = x + y

Fíjate bien, ¡ni siquiera hemos puesto : Int! Como Kotlin cuenta con una característica llamada inferencia de tipos, deduce inmediatamente que si sumas dos Int, el resultado será forzosamente un Int.

(No obstante, si estás trabajando en equipo y quieres que otros programadores lean tu código rápidamente, nunca está de más indicar explícitamente el tipo de retorno: fun sumar(x: Int, y: Int): Int = x + y).

Retornos tempranos en funciones

En ocasiones, quieres salir de una función inmediatamente si se cumple (o no) una condición, sin necesidad de seguir ejecutando y procesando el resto del código. Para eso usamos la palabra return dentro de un condicional if.

val usuariosRegistrados = mutableListOf("juan_perez", "maria_lopez")

fun registrarUsuario(usuario: String): String {
    // Retorno temprano si el usuario ya existe en nuestra base de datos (lista)
    if (usuario in usuariosRegistrados) {
        return "Error: El nombre de usuario ya está pillado. Elige otro."
    }

    // Si no hemos entrado en el if anterior, la función continúa de forma normal
    usuariosRegistrados.add(usuario)
    return "¡Usuario $usuario registrado con éxito!"
}

fun main() {
    println(registrarUsuario("juan_perez"))
    // Salida: Error: El nombre de usuario ya está pillado. Elige otro.
    
    println(registrarUsuario("nuevo_user"))
    // Salida: ¡Usuario nuevo_user registrado con éxito!
}

Expresiones lambda

Kotlin te permite escribir funciones de forma todavía más compacta usando lo que conocemos como expresiones lambda. Básicamente, una lambda es una función anónima (sin nombre) que puedes guardar directamente en una variable o pasarla como si fuera un parámetro más a otras funciones.

Mira esta función normal:

fun aMayusculas(texto: String): String {
    return texto.uppercase()
}

Podemos escribir exactamente lo mismo como una expresión lambda y guardarla en una variable:

val aMayusculasLambda = { texto: String -> texto.uppercase() }

fun main() {
    println(aMayusculasLambda("hola"))
    // Resultado: HOLA
}

Estructura de una lambda:

• Se encapsula siempre entre llaves { }.
• Primero van los parámetros (texto: String).
• Luego una flecha ->.
• Y finalmente el cuerpo de la función (lo que hace y lo que se devuelve de forma automática: texto.uppercase()).

Pasando lambdas a otras funciones

Esto resulta muy útil cuando trabajamos con colecciones (listas, sets, mapas…). Multitud de funciones nativas de colecciones reciben una lambda para saber exactamente qué deben hacer con cada uno de los elementos.

El mejor ejemplo es usar .filter() (para filtrar elementos en base a una condición) o .map() (para transformar los elementos de una lista en otros):

fun main() {
    val numeros = listOf(1, -2, 3, -4, 5, -6)
    
    // Quedarnos solo con los positivos. La lambda comprueba si el número es mayor que 0.
    val positivos = numeros.filter({ x -> x > 0 })
    println(positivos) // [1, 3, 5]
    
    // Multiplicar todos los elementos de la lista por 2 usando map
    val dobles = numeros.map({ x -> x * 2 })
    println(dobles) // [2, -4, 6, -8, 10, -12]
}

Si la lambda es el último o el único parámetro que le pasas a una función (como pasa arriba con filter y map), Kotlin te permite sacarla fuera de los paréntesis (). E incluso puedes omitir los paréntesis por completo si es el único argumento.

Reescribiendo lo anterior de forma idiomática:

val positivos = numeros.filter { x -> x > 0 }

Tipos de funciones

Al igual que una variable puede ser de tipo String o Int, ¡las funciones también tienen su propio tipo! La sintaxis para definir el tipo de una función consiste en poner los parámetros de entrada entre paréntesis y, tras una flecha ->, el tipo que va a devolver.

• (String) -> String (recibe un texto, devuelve un texto)
• (Int, Int) -> Int (recibe dos enteros, devuelve un entero)
• () -> Unit (no recibe absolutamente nada, no devuelve nada útil)

Ejemplo declarando el tipo de forma explícita en una variable:

val sumarLambda: (Int, Int) -> Int = { a, b -> a + b }

Ejercicios

Aquí tienes varios ejercicios de menos a más dificultad (algunos adaptados de la documentación oficial y otros extra para asentar todo lo aprendido). Abre tu Kotlin Playground y vamos a practicar lo aprendido.

El área del círculo

Escribe una función normal llamada areaCirculo que reciba el radio de un círculo en formato entero (Int) y devuelva el área de ese círculo (con decimales).

Pista: Vas a necesitar importar la constante Pi desde kotlin.math.PI. La fórmula es PI * radio * radio.

import kotlin.math.PI
// Escribe tu función aquí

fun main() {
    println(areaCirculo(2)) // Debería dar aprox 12.566...
}

El área del círculo en una sola línea

Reescribe la función areaCirculo del ejercicio anterior pero simplifícala para convertirla en una función de una sola expresión (Single-expression function), eliminando las llaves y el return.

Pasando el tiempo a segundos

Tienes una función que traduce un intervalo de tiempo (horas, minutos y segundos) a segundos totales. La inmensa mayoría de las veces, solo vas a querer pasarle un parámetro y que el resto sean cero por defecto.

Mejora la función y las llamadas en el main utilizando valores por defecto y argumentos nombrados para que el código quede impecable y súper legible.

// Mejora esta función
fun intervaloEnSegundos(horas: Int, minutos: Int, segundos: Int) =
    ((horas * 60) + minutos) * 60 + segundos

fun main() {
    // Mejora estas llamadas
    println(intervaloEnSegundos(1, 20, 15))
    println(intervaloEnSegundos(0, 1, 25))
    println(intervaloEnSegundos(2, 0, 0))
    println(intervaloEnSegundos(0, 10, 0))
    println(intervaloEnSegundos(1, 0, 1))
}

Generador de URLs

Tienes una lista de acciones de una API, un prefijo de una web y el ID de un recurso. Utilizando la función de colección .map() y una expresión lambda, crea una nueva lista de URLs que combinen los tres elementos para formar rutas completas (ejemplo esperado: https://ejemplo.com/libro/5/titulo).

fun main() {
    val acciones = listOf("titulo", "anyo", "autor")
    val prefijo = "https://ejemplo.com/libro"
    val id = 5
    
    val urls = // ¡Escribe aquí tu map con lambda!
    
    println(urls)
}

Repetidor de acciones

Escribe una función llamada repetirN que reciba un número entero n y una acción (una función de tipo () -> Unit). La función debe repetir esa acción el número de veces indicado utilizando un bucle clásico. Luego, en el main, úsala (usando una trailing lambda) para imprimir "¡Me encanta Kotlin!" 5 veces.

El saludo personalizado

Crea una función llamada saludoPersonalizado que reciba un nombre (String), una edad (Int) y una ciudad (String). El parámetro ciudad debe tener el valor por defecto "Madrid".

La función debe usar un println() para mostrar: "Hola, me llamo [nombre], tengo [edad] años y vivo en [ciudad].".

Luego, en el main, llama a la función de dos formas distintas:

1. Pasando solo nombre y edad.
2. Pasando nombre, edad y ciudad, pero utilizando argumentos nombrados en un orden distinto al original.

Filtrando palabras largas

Dada la siguiente lista de palabras: val palabras = listOf("sol", "murciélago", "pan", "ornitorrinco", "luz", "desarrollador")

Utiliza la función .filter() y una trailing lambda para crear una nueva lista que solo contenga las palabras que tengan estrictamente más de 5 letras. (Pista: Los textos o Strings en Kotlin tienen una propiedad llamada .length que te dice lo largos que son). Imprime el resultado final.

Soluciones a los ejercicios

No hagas trampas. Échale un vistazo a las soluciones únicamente cuando te hayas peleado un buen rato con el código.

El área del círculo

import kotlin.math.PI

fun areaCirculo(radio: Int): Double {
    return PI * radio * radio
}

fun main() {
    println(areaCirculo(2)) 
    // 12.566370614359172
}

El área del círculo en una sola línea

import kotlin.math.PI

// Quitamos llaves y return, y usamos el signo '='. Mantener el ': Double' es buena práctica.
fun areaCirculo(radio: Int): Double = PI * radio * radio

fun main() {
    println(areaCirculo(2))
}

Pasando el tiempo a segundos

// Asignamos '= 0' a todos los parámetros para darles un valor por defecto
fun intervaloEnSegundos(horas: Int = 0, minutos: Int = 0, segundos: Int = 0) =
    ((horas * 60) + minutos) * 60 + segundos

fun main() {
    println(intervaloEnSegundos(1, 20, 15)) // Este lo pasamos normal
    println(intervaloEnSegundos(minutos = 1, segundos = 25)) // Omitimos las horas
    println(intervaloEnSegundos(horas = 2)) // Omitimos minutos y segundos
    println(intervaloEnSegundos(minutos = 10))
    println(intervaloEnSegundos(horas = 1, segundos = 1))
}

Generador de URLs

fun main() {
    val acciones = listOf("titulo", "anyo", "autor")
    val prefijo = "https://ejemplo.com/libro"
    val id = 5
    
    // Usamos map para transformar cada elemento. Recuerda usar plantillas de texto ($) para fusionarlo todo.
    val urls = acciones.map { accion -> "$prefijo/$id/$accion" }
    
    println(urls)
    // [https://ejemplo.com/libro/5/titulo, https://ejemplo.com/libro/5/anyo, https://ejemplo.com/libro/5/autor]
}

Repetidor de acciones

// El tipo de la acción es () -> Unit porque es un bloque de código que no recibe nada y no devuelve nada útil.
fun repetirN(n: Int, accion: () -> Unit) {
    for (i in 1..n) {
        accion()
    }
}

fun main() {
    // Como la acción es el último parámetro, podemos sacar las llaves (trailing lambda)
    repetirN(5) {
        println("¡Me encanta Kotlin!")
    }
}

El saludo personalizado

fun saludoPersonalizado(nombre: String, edad: Int, ciudad: String = "Madrid") {
    println("Hola, me llamo $nombre, tengo $edad años y vivo en $ciudad.")
}

fun main() {
    // Llamada 1: usamos el valor por defecto para ciudad
    saludoPersonalizado("Carlos", 28)
    
    // Llamada 2: usamos argumentos nombrados alterando el orden natural
    saludoPersonalizado(ciudad = "Valencia", edad = 32, nombre = "Laura")
}

Filtrando palabras largas

fun main() {
    val palabras = listOf("sol", "murciélago", "pan", "ornitorrinco", "luz", "desarrollador")
    
    // filter con trailing lambda. Solo conservamos la palabra si su longitud es mayor a 5.
    val palabrasLargas = palabras.filter { palabra -> palabra.length > 5 }
    
    println(palabrasLargas)
    // [murciélago, ornitorrinco, desarrollador]
}

Introducción

¿Alguna vez te has preguntado cómo funcionan las entrañas de un videojuego clásico? Hoy no vamos a usar librerías gráficas pesadas como Unity o Unreal. Vamos a bajar al metal, al código puro. Vamos a construir un juego funcional para Space Invaders utilizando únicamente la consola de Java.

Aprenderemos sobre Herencia, Polimorfismo, Ciclos de Juego (Game Loops) y Detección de Colisiones en una rejilla.

En este enlace puedes encontrar una presentación explicando el código, y a continuación dispones de una infografía y un vídeo explicativo.

Control de entrada con Enum

En lugar de esparcir caracteres mágicos ('a', 'd', 'f') por todo el código, vamos a profesionalizar la entrada del usuario. Usaremos un Enum.

¿Y por qué un Enum? Un enumerado nos permite definir un tipo de dato que tiene un conjunto fijo de constantes. Esto hace que el código sea seguro (no puedes pasar una tecla que no exista) y legible. Además, encapsulamos la lógica: cada tecla sabe cuál es su descripción y su carácter asociado. Fíjate por ejemplo en el método detectar. Recorre todos los valores posibles y compara. Si el usuario escribe «I» o «i», el juego entenderá Input.IZQUIERDA independientemente de lo que pase después.

import java.util.Scanner;

/**
 * Enumeración que gestiona el control de entrada del usuario.
 * Define las teclas válidas y asocia cada una con una acción del juego.
 */
enum Input {
    IZQUIERDA("i", "Izquierda"), 
    DERECHA("d", "Derecha"), 
    FUEGO("f", "FUEGO"), 
    SALIR("x", "Salir"), 
    NADA("", ""); 

    private String tecla;
    private String descripcion;

    /**
     * Constructor del enum Input.
     * @param tecla Carácter que activa la acción.
     * @param descripcion Nombre legible de la acción.
     */
    Input(String tecla, String descripcion) { 
        this.tecla = tecla; 
        this.descripcion = descripcion;
    }

    /**
     * Imprime en la consola la lista de controles disponibles para el jugador.
     */
    public static void imprimirControles() {
        for (Input i : Input.values()) {
            if (!i.tecla.isEmpty()) System.out.print("[" + i.tecla + "]" + i.descripcion + "  ");
        }
        System.out.print("\nAcción > ");
    }

    /**
     * Detecta qué comando corresponde al texto introducido por el usuario.
     * @param texto Entrada del teclado.
     * @return La instancia de Input correspondiente o NADA si no coincide.
     */
    public static Input detectar(String texto) {
        for (Input i : Input.values()) {
            if (i.tecla.equalsIgnoreCase(texto)) return i;
        }
        return NADA;
    }
}

Herencia y polimorfismo

Aplicamos el principio DRY (Don’t Repeat Yourself). Una Nave, un Alien y una Bala son cosas muy distintas, pero comparten cierta información: todos tienen una coordenada X, una coordenada Y y un icono para dibujarse.

La clase Entidad

Esta clase define lo que es un objeto en nuestro juego. Además, incluye una lógica de protección: el método mover base se asegura de que ningún objeto se salga del mapa usando Math.max y Math.min.

/**
 * Clase base para todos los objetos del juego (Nave, Alien, Bala).
 * Contiene la posición y el icono representativo.
 */
class Entidad {
    protected int x, y;
    protected char icono;

    public Entidad(int x, int y, char icono) {
        this.x = x; 
        this.y = y; 
        this.icono = icono;
    }

    /**
     * Actualiza la posición de la entidad y aplica restricciones de los límites del mapa.
     * @param accion La acción de entrada del usuario.
     */
    public void mover(Input accion) {
        // Restringir X entre 0 y ANCHO - 1
        x = Math.max(0, Math.min(x, JuegoInvasores.ANCHO - 1));
        // Restringir Y entre -1 y ALTO
        y = Math.max(-1, Math.min(y, JuegoInvasores.ALTO));
    }
}

Las especializaciones: Nave, Alien y Bala

Aquí es donde brilla la Orientación a Objetos. Cada clase sobrescribe (@Override) el método mover para comportarse de forma distinta, pero el motor del juego las tratará a todas igual (como Entidad).

1. Nave: Solo reacciona si el jugador pulsa Izquierda o Derecha.
2. Alien: Ignora al jugador y siempre baja (y++).
3. Bala: Ignora al jugador y siempre sube (y--).

class Nave extends Entidad {
    public Nave(int x, int y) { super(x, y, 'A'); }
    
    @Override
    public void mover(Input accion) {
        if (accion == Input.IZQUIERDA) x--;
        if (accion == Input.DERECHA)   x++;
        super.mover(accion); // Importante: Llamamos al padre para que verifique los bordes
    }
}

class Alien extends Entidad {
    public Alien(int x, int y) { super(x, y, 'V'); }
    
    @Override
    public void mover(Input accion) {
        y++; // El alien cae por gravedad
        super.mover(accion);
    }
}

class Bala extends Entidad {
    public Bala(int x, int y) { super(x, y, '|'); }
    
    @Override
    public void mover(Input accion) {
        y--; // La bala desafía la gravedad
        super.mover(accion);
    }
}

Gestión de memoria y bucle principal

En Java, especialmente en juegos simples, un Array es la estructura más eficiente. Definimos un array Entidad[] objetos que contendrá todo lo que existe en el universo del juego.

El Bucle de Juego (Game Loop) es infinito (while(jugando)) y sigue estos pasos:

1. Render: Dibujar el mundo.
2. Input: Leer al usuario.
3. Update: Mover cosas y disparar.
4. Collision: Verificar reglas del juego.

Inicialización y disparo

Observa cómo manejamos el disparo. No creamos listas dinámicas (ArrayList) para simplificar. Buscamos un hueco null en el array y metemos la bala ahí. Es una técnica de «Object Pooling» primitiva pero eficaz.

public class JuegoInvasores {
    static final int ANCHO = 10, ALTO = 12;
    static final int MAX_ALIENS = 2, MAX_ENTIDADES = 30;

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        Entidad[] objetos = new Entidad[MAX_ENTIDADES];

        // Inicializamos la Nave y los Aliens
        objetos[0] = new Nave(ANCHO / 2, ALTO - 1);
        for (int i = 1; i <= MAX_ALIENS; i++) {
            objetos[i] = new Alien((int)(Math.random() * ANCHO), 0);
        }

        boolean jugando = true;
        while (jugando) {
            dibujarJuego(objetos);
            Input.imprimirControles(); 
            Input accion = Input.detectar(scanner.nextLine());

            if (accion == Input.SALIR) {
                jugando = false;
            } else {
                // LOGICA DE DISPARO
                if (accion == Input.FUEGO) {
                    boolean balaDisparada = false; 
                    // Buscamos un hueco vacío en el array para crear la bala
                    for (int i = 0; i < objetos.length && !balaDisparada; i++) {
                        if (objetos[i] == null && objetos[0] != null) {
                            objetos[i] = new Bala(objetos[0].x, objetos[0].y);
                            balaDisparada = true; 
                        }
                    }
                }

                // ACTUALIZACION DE POSICIONES (POLIMORFISMO)
                for (Entidad e : objetos) {
                    if (e != null) e.mover(accion);
                }
                
                // ... (Ver siguiente sección)

Detección de Colisiones

Esta es la parte más compleja matemáticamente. En un juego por turnos en consola, una bala se mueve de la casilla 5 a la 4, y un alien de la 3 a la 4. ¿Pero qué pasa si se cruzan? Hemos implementado una verificación predictiva. Comprobamos si la bala está en la misma casilla que el alien (posibleBala.y == alien.y) O si acaba de cruzarlo (posibleBala.y == alien.y - 1).

    // ... dentro del bucle main
    int estadoJuego = procesarColisiones(objetos);
    if (estadoJuego == -1) {
        dibujarJuego(objetos);
        System.out.println("\n¡GAME OVER!");
        jugando = false;
    } else if (estadoJuego == 0) {
        dibujarJuego(objetos);
        System.out.println("\n¡VICTORIA!");
        jugando = false;
    }

Funciones de lógica del juego

Aquí se decide quién vive y quién muere. Usamos instanceof para saber qué tipo de entidad estamos comprobando.

    static int procesarColisiones(Entidad[] objetos) {
        int aliensVivos = 0;
        boolean invasion = false;

        for (int i = 0; i < objetos.length; i++) {
            Entidad ent = objetos[i];
            if (ent != null) {
                
                // Limpieza: Si algo se sale del mapa, lo borramos (ponemos a null)
                if (ent.y < 0 || ent.y >= ALTO) {
                    if (!(ent instanceof Nave)) objetos[i] = null;
                } else {
                    if (ent instanceof Alien) {
                        // Si un alien toca el fondo, perdemos
                        if (ent.y >= ALTO - 1) invasion = true;
                        
                        // Verificamos si este alien ha chocado con alguna bala
                        boolean impactado = verificarImpacto(ent, objetos);

                        if (impactado) {
                            objetos[i] = null; // Eliminamos el Alien
                            System.out.println("¡ALIEN DESTRUIDO!");
                        } else {
                            aliensVivos++;
                        }
                    }
                }
            }
        }
        if (invasion) return -1;
        return aliensVivos;
    }

    // Algoritmo de colisión cruzada
    static boolean verificarImpacto(Entidad alien, Entidad[] todosLosObjetos) {
        boolean impacto = false;
        for (int j = 0; j < todosLosObjetos.length; j++) {
            if (!impacto) {
                 Entidad posibleBala = todosLosObjetos[j];
                 if (posibleBala instanceof Bala 
                     && posibleBala.x == alien.x 
                     && (posibleBala.y == alien.y || posibleBala.y == alien.y - 1)) {
                    
                     todosLosObjetos[j] = null; // Eliminamos la Bala
                     impacto = true;
                 }
            }
        }
        return impacto;
    }

Dibujando la matriz

Finalmente, necesitamos ver lo que ocurre. La técnica usada aquí es crear un «Lienzo en blanco» (matriz de puntos), pintar las entidades encima y luego imprimirlo todo de golpe. Esto evita parpadeos y asegura que si dos objetos están en la misma casilla, uno se dibuje sobre el otro (el último en procesarse gana).

    static void dibujarJuego(Entidad[] lista) {
        // 1. Crear lienzo vacío
        char[][] matriz = new char[ALTO][ANCHO];
        for(int y=0; y<ALTO; y++) {
            for(int x=0; x<ANCHO; x++) {
                matriz[y][x] = '.';
            }
        }

        // 2. Pintar entidades
        for(Entidad e : lista) {
            if (e != null && e.y >= 0 && e.y < ALTO) {
                matriz[e.y][e.x] = e.icono;
            }
        }

        // 3. Imprimir en consola
        System.out.print("\n\n");
        for(int y=0; y<ALTO; y++) {
            for(int x=0; x<ANCHO; x++) {
                System.out.print(matriz[y][x] + " ");
            }
            System.out.println();
        }
    }
}

Todo el código

import java.util.Scanner;

/**
 * Enumeración que gestiona el control de entrada del usuario.
 * Define las teclas válidas y asocia cada una con una acción del juego.
 */
enum Input {
    IZQUIERDA("i", "Izquierda"), 
    DERECHA("d", "Derecha"), 
    FUEGO("f", "FUEGO"), 
    SALIR("x", "Salir"), 
    NADA("", ""); 

    private String tecla;
    private String descripcion;

    /**
     * Constructor del enum Input.
     * @param tecla Carácter que activa la acción.
     * @param descripcion Nombre legible de la acción.
     */
    Input(String tecla, String descripcion) { 
        this.tecla = tecla; 
        this.descripcion = descripcion;
    }

    /**
     * Imprime en la consola la lista de controles disponibles para el jugador.
     */
    public static void imprimirControles() {
        for (Input i : Input.values()) {
            if (!i.tecla.isEmpty()) System.out.print("[" + i.tecla + "]" + i.descripcion + "  ");
        }
        System.out.print("\nAcción > ");
    }

    /**
     * Detecta qué comando corresponde al texto introducido por el usuario.
     * @param texto Entrada del teclado.
     * @return La instancia de Input correspondiente o NADA si no coincide.
     */
    public static Input detectar(String texto) {
        for (Input i : Input.values()) {
            if (i.tecla.equalsIgnoreCase(texto)) return i;
        }
        return NADA;
    }
}

// ========================================================
// 2. CLASES (HERENCIA Y COMPORTAMIENTO BASE)
// ========================================================

/**
 * Clase base para todos los objetos del juego (Nave, Alien, Bala).
 * Contiene la posición y el icono representativo.
 */
class Entidad {
    protected int x, y;
    protected char icono;

    /**
     * Constructor de una Entidad.
     * @param x Posición horizontal inicial.
     * @param y Posición vertical inicial.
     * @param icono Carácter que representa a la entidad en el mapa.
     */
    public Entidad(int x, int y, char icono) {
        this.x = x; 
        this.y = y; 
        this.icono = icono;
    }

    /**
     * Actualiza la posición de la entidad y aplica restricciones de los límites del mapa.
     * @param accion La acción de entrada del usuario (opcional según el tipo de entidad).
     */
    public void mover(Input accion) {
        // Restringir X entre 0 y ANCHO - 1
        x = Math.max(0, Math.min(x, JuegoInvasores.ANCHO - 1));

        // Restringir Y entre -1 (para que las balas salgan) y ALTO
        y = Math.max(-1, Math.min(y, JuegoInvasores.ALTO));
    }
}

/**
 * Representa la nave controlada por el jugador.
 */
class Nave extends Entidad {
    /**
     * Crea una nave en una posición específica con el icono 'A'.
     * @param x Posición horizontal.
     * @param y Posición vertical.
     */
    public Nave(int x, int y) { 
        super(x, y, 'A'); 
    }
    
    /**
     * Mueve la nave horizontalmente según el input.
     * @param accion Dirección del movimiento (IZQUIERDA o DERECHA).
     */
    @Override
    public void mover(Input accion) {
        if (accion == Input.IZQUIERDA) x--;
        if (accion == Input.DERECHA)   x++;
        super.mover(accion); // Ejecuta el control de límites de la clase Entidad
    }
}

/**
 * Representa a los enemigos que descienden por la pantalla.
 */
class Alien extends Entidad {
    /**
     * Crea un alien con el icono 'V'.
     * @param x Posición horizontal.
     * @param y Posición vertical.
     */
    public Alien(int x, int y) { 
        super(x, y, 'V'); 
    }
    
    /**
     * Mueve al alien una posición hacia abajo en cada turno.
     * @param accion No se utiliza para el alien, ya que su movimiento es automático.
     */
    @Override
    public void mover(Input accion) {
        y++; // El alien siempre baja
        super.mover(accion);
    }
}

/**
 * Representa el proyectil disparado por la nave.
 */
class Bala extends Entidad {
    /**
     * Crea una bala con el icono '|'.
     * @param x Posición horizontal.
     * @param y Posición vertical.
     */
    public Bala(int x, int y) { 
        super(x, y, '|'); 
    }
    
    /**
     * Mueve la bala una posición hacia arriba en cada turno.
     * @param accion No se utiliza para la bala.
     */
    @Override
    public void mover(Input accion) {
        y--; // La bala siempre sube
        super.mover(accion);
    }
}

// ========================================================
// 3. MOTOR DEL JUEGO
// ========================================================

/**
 * Clase principal que contiene el bucle del juego y la lógica de renderizado.
 */
public class JuegoInvasores {
    static final int ANCHO = 12, ALTO = 12;
    static final int MAX_ALIENS = 3, MAX_ENTIDADES = 30; // Limite total de entidades

    /**
     * Punto de entrada principal del programa.
     * @param args Argumentos de línea de comandos.
     */
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        Entidad[] objetos = new Entidad[MAX_ENTIDADES];

        // --- INICIO ---
        objetos[0] = new Nave(ANCHO / 2, ALTO - 1);
        for (int i = 1; i <= MAX_ALIENS; i++) {
            objetos[i] = new Alien((int)(Math.random() * ANCHO), 0);
        }

        boolean jugando = true;
        while (jugando) {
            dibujarJuego(objetos);
            Input.imprimirControles(); 
            Input accion = Input.detectar(scanner.nextLine());

            if (accion == Input.SALIR) {
                jugando = false;
            } else {
                // --- DISPARAR (Crea una bala en la posición de la nave) ---
                if (accion == Input.FUEGO) {
                    boolean balaDisparada = false; 
                    for (int i = 0; i < objetos.length && !balaDisparada; i++) {
                        if (objetos[i] == null) {
                            if (objetos[0] != null) {
                                objetos[i] = new Bala(objetos[0].x, objetos[0].y);
                                balaDisparada = true; // Evita seguir buscando huecos
                            }
                        }
                    }
                }

                // --- ACTUALIZAR POSICIONES ---
                for (Entidad e : objetos) {
                    if (e != null) e.mover(accion);
                }

                // --- GESTIÓN DE COLISIONES Y ESTADO ---
                int estadoJuego = procesarColisiones(objetos);

                if (estadoJuego == -1) {
                    dibujarJuego(objetos);
                    System.out.println("\n¡GAME OVER!");
                    jugando = false;
                } else if (estadoJuego == 0) {
                    dibujarJuego(objetos);
                    System.out.println("\n¡VICTORIA!");
                    jugando = false;
                }
            }
        }
        scanner.close();
    }

    /**
     * Procesa la limpieza de proyectiles fuera del mapa, detecta invasiones y gestiona colisiones.
     * @param objetos Array que contiene todas las entidades activas del juego.
     * @return El número de aliens vivos, o -1 si el jugador ha perdido (invasión).
     */
    static int procesarColisiones(Entidad[] objetos) {
        int aliensVivos = 0;
        boolean invasion = false;

        for (int i = 0; i < objetos.length; i++) {
            Entidad ent = objetos[i];

            if (ent != null) {
                // 1. Limpieza de proyectiles o aliens fuera de rango
                if (ent.y < 0 || ent.y >= ALTO) {
                    if (!(ent instanceof Nave)) objetos[i] = null;
                } else {
                    // 2. Lógica específica para Aliens
                    if (ent instanceof Alien) {
                        
                        // Comprobar si ha llegado al final (invasión)
                        if (ent.y >= ALTO - 1) { 
                             invasion = true;
                        }
                        
                        // 3. Colisión Bala-Alien
                        // Pasamos el alien actual (ent) y la lista completa para buscar balas
                        boolean impactado = verificarImpacto(ent, objetos);

                        if (impactado) {
                            objetos[i] = null; // Borra Alien
                            System.out.println("¡ALIEN DESTRUIDO!");
                        } else {
                            // Solo contamos el alien si NO ha sido destruido
                            aliensVivos++;
                        }
                    }
                }
            }
        }

        if (invasion) return -1; // Código de derrota
        return aliensVivos;      // Retorna cuántos quedan
    }

    /**
     * Verifica si una bala ha impactado en un alien específico.
     * @param alien El alien que se va a comprobar.
     * @param todosLosObjetos Array completo para buscar balas activas.
     * @return true si el alien fue impactado por una bala, false en caso contrario.
     */
    static boolean verificarImpacto(Entidad alien, Entidad[] todosLosObjetos) {
        boolean impacto = false;
        
        for (int j = 0; j < todosLosObjetos.length; j++) {
            // Comprobamos solo si no hemos impactado ya en este ciclo (sin break)
            if (!impacto) {
                 Entidad posibleBala = todosLosObjetos[j];
                 
                 // Verificamos si es Bala y si las coordenadas coinciden
                 // Nota: (alien.y - 1) arregla el problema de colisiones cruzadas
                 if (posibleBala instanceof Bala 
                     && posibleBala.x == alien.x 
                     && (posibleBala.y == alien.y || posibleBala.y == alien.y - 1)) {
                    
                     todosLosObjetos[j] = null; // Borra Bala
                     impacto = true;   // Marca que hubo impacto
                 }
            }
        }
        return impacto;
    }

    /**
     * Dibuja el estado actual del juego en la consola mediante una matriz de caracteres.
     * @param lista Array de entidades a dibujar sobre el mapa.
     */
    static void dibujarJuego(Entidad[] lista) {
        char[][] matriz = new char[ALTO][ANCHO];
        for(int y=0; y<ALTO; y++) {
            for(int x=0; x<ANCHO; x++) {
                matriz[y][x] = '.';
            }
        }

        for(Entidad e : lista) {
            if (e != null && e.y >= 0 && e.y < ALTO) {
                matriz[e.y][e.x] = e.icono;
            }
        }

        System.out.print("\n\n");
        for(int y=0; y<ALTO; y++) {
            for(int x=0; x<ANCHO; x++) {
                System.out.print(matriz[y][x] + " ");
            }
            System.out.println();
        }
    }
}

Conclusión

Hemos construido un juego completo en unas pocas clases. Lo importante de este ejercicio no es el juego en sí, sino cómo hemos estructurado los datos:

1. Entidades autónomas: La clase Nave no necesita saber cómo funciona el Alien.
2. Control centralizado: El Main orquesta todo, pero delega el movimiento a cada objeto.
3. Tipado fuerte: El uso de Enum previene errores tontos de teclado.

Introducción

En esta unidad, vamos a desglosar una implementación avanzada del juego clásico de estrategia naval. A diferencia de otros ejemplos que pueden ser más simples, este código introduce los siguientes conceptos a nivel más avanzado:

1. Motor de renderizado ANSI: Manipulación de la consola del sistema operativo para mostrar colores.
2. Modelo de datos robusto: Uso de enumerados (enum) para encapsular comportamiento y configuración.
3. Algoritmos de colocación espacial: Lógica matemática para gestionar colisiones y perímetros de seguridad en una matriz.
4. Niebla de guerra: Separación entre el estado interno del programa y lo que se muestra al usuario.

En este enlace puedes encontrar una presentación explicando el código, y a continuación dispones de una infografía y un vídeo explicativo.

Estructuras de datos: El uso de enum frente a enteros

Implementación en el enum TipoBarco

El objetivo principal de este enum es actuar como bloque de definición de datos para la configuración de la flota, persiguiendo los siguientes objetivos:

• Centralización de reglas: Imagina que quieres cambiar las reglas del juego para que el submarino sea más grande (4 casillas en vez de 3). Si usaras variables sueltas dispersas por el código, tendrías que buscar y cambiar ese número en varios sitios. Con este enum, cambias el número en una sola línea (SUBMARINO(4)) y todo el juego (condiciones de victoria, lógica de colocación, etc.) se actualiza automáticamente.
• Eliminación de «números mágicos»: En programación, encontrar un 5 suelto en el código es confuso (¿es la munición? ¿es el tamaño del tablero?). Al usar TipoBarco.PORTAAVIONES.getLongitud(), el código se explica por sí mismo.
• Agrupación lógica: Vincula inseparablemente el nombre de la entidad (portaaviones) con su propiedad (tamaño 5). No puedes tener un portaaviones sin tamaño, ni un tamaño sin barco.

Cuando el programa arranca, Java crea automáticamente una única instancia para cada uno de estos nombres. Por ejemplo, al escribir PORTAAVIONES(5), Java está haciendo internamente algo similar a: new TipoBarco(5). Le está pasando el valor 5 al constructor. De esta forma, cada barco tiene su propia variable interna llamada longitud, con las siguientes características:

• Es private: Nadie desde fuera puede modificarla directamente. Para acceder a su valor, utilizaremos un método público para que el resto del programa pueda preguntar: «¿Cuánto mide este barco?»
• Es final: Una vez asignada, no puede cambiar. Un destructor siempre medirá 2 durante toda la ejecución del programa. Esto garantiza la integridad de las reglas.

    /**
     * Define los tipos de barcos y sus longitudes.
     * Centraliza la configuración: si cambiamos un número aquí, el juego se adapta.
     */
    enum TipoBarco {
        PORTAAVIONES(5),
        ACORAZADO(4),
        CRUCERO(3),
        SUBMARINO(3),
        DESTRUCTOR(2);

        private final int longitud;

        TipoBarco(int longitud) {
            this.longitud = longitud;
        }

        public int getLongitud() {
            return longitud;
        }
    }

Estructura de colores RGB en consola

Esta es una de las partes más interesantes del código. Java, por defecto, imprime texto plano en la consola. Sin embargo, los terminales modernos (CMD, PowerShell, Bash) soportan Secuencias de Escape ANSI.

Cuando imprimimos un carácter especial llamado ESCAPE (código ASCII 27, representado en Java como \u001B), le estamos diciendo a la consola: «Atención, lo que viene a continuación no es texto para leer, es una orden de configuración».

El código implementa el estándar RGB TrueColor con la estructura «\u001B[38;2;R;G;Bm«:

• \u001B[: Inicio de la secuencia de control (CSI).
• 38: Indica que vamos a cambiar el color del texto (foreground).
• 2: Indica que usaremos el modo RGB (Red, Green, Blue).
• R;G;B: Son tres números del 0 al 255 que definen la mezcla de color.
• m: Indica el fin de la instrucción.

Implementación en el enum EstadoCasilla

En lugar de escribir estos códigos crípticos cada vez que queremos imprimir algo, los encapsulamos en el constructor del enum:

1. Constructor: Recibe los valores enteros R, G y B.
2. String.format: Construye la secuencia ANSI dinámica.
3. toString: Sobrescribe el método estándar para devolver: COLOR + SÍMBOLO + RESET. El código de RESET (\u001B[0m) es vital; si no lo pusiéramos, toda la consola se quedaría pintada de ese color indefinidamente.

    /**
     * Motor de colores RGB.
     * Transforma códigos numéricos en secuencias de escape ANSI.
     */
    enum EstadoCasilla {
        // Definición semántica con sus valores visuales (Símbolo, R, G, B)
        AGUA     ( "~",      0, 180, 255),   // Agua (azul claro)
        BARCO    ( "B",    160,  32, 240),   // Púrpura (visible al acabar)
        TOCADO   ( "X",    255,   0,   0),   // Rojo puro (impacto)
        FALLO    ( "o",    180, 180, 180);   // Gris (agua con impacto)

        private final String simbolo;
        private final String codigoColor;
        // Secuencia para restablecer el color por defecto de la terminal
        private static final String RESET = "\u001B[0m";

        /**
         * Constructor que inyecta la lógica de color.
         * La secuencia mágica es: \u001B[38;2;R;G;Bm
         */
        EstadoCasilla(String simbolo, int r, int g, int b) {
            this.simbolo = simbolo;
            this.codigoColor = String.format("\u001B[38;2;%d;%d;%dm", r, g, b);
        }

        @Override
        public String toString() {
            // Devuelve: [Instrucción Color] + [Carácter] + [Instrucción Reset]
            return codigoColor + simbolo + RESET;
        }
    }

Gestión de memoria y estado global

Para gestionar el tablero, utilizamos una matriz bidimensional de objetos EstadoCasilla.

• static EstadoCasilla[][] oceano: Es la representación en memoria del mar. Cada celda [fila][columna] contiene una referencia a una de las constantes del Enum (AGUA, BARCO, etc.).
• Cálculo dinámico de victoria: La constante IMPACTOS_NECESARIOS no se fija a mano (ej: 17). Se calcula llamando a una función que suma las longitudes de todos los barcos definidos. Esto hace el código extremadamente robusto: si mañana añadimos un nuevo barco al enum, la condición de victoria se recalcula sola sin tocar el resto del código.

    // CONSTANTES Y ESTADO GLOBAL

    static final int DIMENSION = 10; // Tamaño del tablero 10x10
    static final int NO_ENCONTRADO = -1; // Centinela para búsquedas fallidas

    // Configuración de dificultad
    static final int MUNICION_MAXIMA = 50;
    // Cálculo dinámico de la condición de victoria
    static final int IMPACTOS_NECESARIOS = calcularPuntosTotales();

    // La Matriz Principal (El "Tablero")
    static EstadoCasilla[][] oceano = new EstadoCasilla[DIMENSION][DIMENSION];
    
    // Herramientas de entrada y aleatoriedad
    static Scanner teclado = new Scanner(System.in);
    static Random radar = new Random();

El ciclo de vida del juego

El método main se encarga de la ejecución temporal del programa. Podemos distinguir tres fases claras:

1. Fase de inicialización:
   • Limpia el tablero (inicializarOceano).
   • Coloca los barcos sin que el jugador sepa dónde están (colocarFlotaCompleta).
2. Fase de ejecución (bucle while):
   • Renderizado: Llama a imprimirOceano(false). El parámetro false activa la «niebla de guerra», ocultando los barcos.
   • Input: Solicita coordenadas y valida que no se repitan.
   • Lógica: Actualiza el estado de la matriz (de AGUA/BARCO a FALLO/TOCADO).
3. Fase de clausura:
   • Al terminar (victoria o derrota), llama a imprimirOceano(true). El parámetro true desactiva la niebla y revela la ubicación de todos los barcos.

    public static void main(String[] args) {
        System.out.println("--- HUNDIR LA FLOTA ---");
        System.out.println("Tablero: " + DIMENSION + "x" + DIMENSION);
        System.out.println("Objetivo: " + IMPACTOS_NECESARIOS + " impactos.");
        System.out.println("Munición: " + MUNICION_MAXIMA + " misiles.");

        // 1. Fase de Preparación
        inicializarOceano();
        colocarFlotaCompleta();

        // Variables de control de flujo
        int aciertos = 0;
        int misilesRestantes = MUNICION_MAXIMA;
        boolean juegoTerminado = false;

        // 2. Bucle Principal (Game Loop)
        while (!juegoTerminado) {
            // Renderizamos con Niebla de Guerra (false)
            imprimirOceano(false); 

            System.out.println("------------------------------------------------");
            System.out.println("Misiles: " + misilesRestantes + " | Aciertos: " + aciertos + "/" + IMPACTOS_NECESARIOS);

            // Turno del jugador
            boolean impacto = realizarDisparo();
            misilesRestantes--;

            // Feedback visual inmediato
            if (impacto) {
                aciertos++;
                System.out.println(">>> ¡IMPACTO CONFIRMADO! <<<");
            } else {
                System.out.println(">>> Agua. Sin rastro del enemigo. <<<");
            }

            // 3. Comprobación de condiciones de fin
            if (aciertos == IMPACTOS_NECESARIOS) {
                juegoTerminado = true;
                imprimirOceano(true); // Revelamos el mapa (Cheat mode activado legalmente)
                System.out.println("\n¡VICTORIA! Has desmantelado la flota enemiga.");

            } else if (misilesRestantes == 0) {
                juegoTerminado = true;
                imprimirOceano(true);
                System.out.println("\n¡MUNICIÓN AGOTADA! Retirada táctica.");
            }
        }
    }

La meta del juego: calcularPuntosTotales()

Esta función es muy inteligente porque no usa un número «fijo» (como decir que se gana con 10 puntos). En su lugar, pregunta a los barcos cuánto miden.

• TipoBarco.values(): Esto obtiene una lista de todos los tipos de barcos que has definido (Portaaviones, Submarino, etc.).
• El bucle for: Recorre cada barco, mira su longitud (getLongitud()) y la suma a la variable suma.
• ¿Por qué es útil?: Si mañana decides añadir un barco más o cambiar el tamaño de uno, no tienes que tocar el código de victoria; el programa calculará automáticamente que ahora hacen falta, por ejemplo, 17 puntos en lugar de 15.

    /**
     * Calcula dinámicamente cuántos puntos hacen falta para ganar.
     */
    static int calcularPuntosTotales() {
        int suma = 0;
        for (TipoBarco barco : TipoBarco.values()) {
            suma += barco.getLongitud();
        }
        return suma;
    }

El turno del jugador: realizarDisparo()

Esta función debe validar los datos introducidos por el usuario y actualizar el mapa. Se divide en dos bloques:

El bucle de validación (while)

El objetivo de este bloque es que el jugador no pierda el turno por un error en la introducción de datos o en la elección de la casilla donde quiere efectuar el disparo.

1. Entrada de datos: Pide fila y columna.
2. Comprobación de repetición: Mira en la matriz oceano[fila][col].
   • Si el valor es TOCADO o FALLO, significa que ya hubo un proyectil ahí.
   • Importante: Mientras el disparo no sea «nuevo», disparoValido sigue siendo false y el bucle se repite indefinidamente. El jugador no saldrá de aquí hasta que dé una coordenada válida donde no se haya disparado todavía.

Resolución del impacto (if-else)

Una vez que tenemos una coordenada válida, el programa decide qué hay debajo:

• Si hay un BARCO:
  • Cambia el estado a TOCADO (para que el dibujo del mapa cambie).
  • return true: Esto le dice al resto del programa: «¡Oye, suma un punto al marcador!».
• Si no hay barco (es decir, hay agua):
  • Cambia el estado a FALLO.
  • return false: El contador de impactos no cambia.

Conceptos clave de Java en este código

• Enums (EstadoCasilla y TipoBarco): El código no usa números sueltos (como 0 o 1), sino nombres claros. Es mucho más fácil leer EstadoCasilla.TOCADO que leer un 2 y tener que recordar qué significaba.
• Booleans como control: El uso de disparoValido actúa como un «cerrojo» para asegurar que la gestión del impacto se realice con datos correctos.

    /**
     * Procesa el turno de disparo.
     * Devuelve true si acertamos a un barco, false si damos en agua.
     */
    static boolean realizarDisparo() {
        boolean disparoValido = false;
        int fila = NO_ENCONTRADO;
        int col = NO_ENCONTRADO;

        // Bucle de validación de entrada lógica
        while (!disparoValido) {
            fila = pedirCoordenada("Fila (0-" + (DIMENSION - 1) + "): ");
            col = pedirCoordenada("Columna (0-" + (DIMENSION - 1) + "): ");

            // Evitar disparar dos veces al mismo sitio
            if (oceano[fila][col] == EstadoCasilla.TOCADO || oceano[fila][col] == EstadoCasilla.FALLO) {
                System.out.println("Ya has disparado en esa zona. Elige otra.");
            } else {
                disparoValido = true;
            }
        }

        // Resolución del impacto en la matriz
        if (oceano[fila][col] == EstadoCasilla.BARCO) {
            oceano[fila][col] = EstadoCasilla.TOCADO;
            return true;
        } else {
            oceano[fila][col] = EstadoCasilla.FALLO;
            return false;
        }
    }

Distribución de barcos: geometría y «regla del aire»

Esta es la sección más compleja algorítmicamente. El objetivo es colocar barcos aleatoriamente pero cumpliendo dos reglas estrictas:

1. El barco no debe salirse del tablero.
2. Regla del aire: El barco no puede tocar a otro, ni siquiera en diagonal. Debe haber al menos una casilla de agua de separación.

El algoritmo de «bounding box» (caja delimitadora)

En la función esPosicionValida, calculamos un rectángulo de seguridad. Por ejemplo, si el barco va de la fila F a la fila F+3 (tamaño 4), revisamos desde F-1 hasta F+4.

Para evitar errores de «índice fuera de rango» (por ejemplo, si intentáramos revisar la fila -1), utilizamos las funciones matemáticas Math.max(0, ...) y Math.min(DIMENSION-1, ...). Esto «recorta» el área de búsqueda a los límites reales del tablero.

    // ALGORITMOS DE COLOCACIÓN

    static void colocarFlotaCompleta() {
        for (TipoBarco barco : TipoBarco.values()) {
            colocarBarcoAleatorio(barco);
        }
    }

    /**
     * Algoritmo de Fuerza Bruta (Trial & Error).
     * Intenta coordenadas al azar hasta encontrar una válida.
     */
    static void colocarBarcoAleatorio(TipoBarco barco) {
        boolean colocado = false;

        while (!colocado) {
            int fila = radar.nextInt(DIMENSION);
            int col = radar.nextInt(DIMENSION);
            boolean horizontal = radar.nextBoolean();

            if (esPosicionValida(fila, col, barco.getLongitud(), horizontal)) {
                pintarBarcoEnMatriz(fila, col, barco.getLongitud(), horizontal);
                colocado = true;
            }
        }
    }

    /**
     * Valida si un barco cabe y respeta el perímetro de seguridad.
     */
    static boolean esPosicionValida(int f, int c, int longitud, boolean horizontal) {
        // 1. Determinar dimensiones del barco
        int anchoBarco = horizontal ? longitud : 1;
        int altoBarco  = horizontal ? 1 : longitud;

        // 2. Verificar límites del tablero
        if (f + altoBarco > DIMENSION || c + anchoBarco > DIMENSION) {
            return false;
        }

        // 3. Definir el "Marco de Seguridad" (Bounding Box)
        // Usamos Math.max y min para no salirnos de los índices 0-9
        int filaInicio = Math.max(0, f - 1);
        int colInicio  = Math.max(0, c - 1);

        int filaFin = Math.min(DIMENSION - 1, f + altoBarco);
        int colFin  = Math.min(DIMENSION - 1, c + anchoBarco);

        // 4. Escaneo de Área
        for (int i = filaInicio; i <= filaFin; i++) {
            for (int j = colInicio; j <= colFin; j++) {
                // Si encontramos CUALQUIER COSA que no sea agua pura, la posición es inválida
                if (oceano[i][j] != EstadoCasilla.AGUA) {
                    return false; 
                }
            }
        }
        return true; // Zona despejada
    }

    static void pintarBarcoEnMatriz(int f, int c, int longitud, boolean horizontal) {
        for (int i = 0; i < longitud; i++) {
            if (horizontal) {
                oceano[f][c + i] = EstadoCasilla.BARCO;
            } else {
                oceano[f + i][c] = EstadoCasilla.BARCO;
            }
        }
    }

---

Renderizado y utilidades

Finalmente, necesitamos dibujar el tablero. La función imprimirOceano aplica el concepto de niebla de guerra.

• Recorre la matriz celda por celda.
• Si la celda contiene un BARCO y estamos en modo juego (revelarTodo == false), el programa miente al usuario e imprime el símbolo de AGUA.
• Esto demuestra cómo separar los datos (lo que hay en memoria) de la vista (lo que ve el usuario).

También incluimos pedirCoordenada con hasNextInt() para evitar que el programa falle si el usuario introduce letras.

    // UTILIDADES Y VISTA

    static void inicializarOceano() {
        for (int f = 0; f < DIMENSION; f++) {
            for (int c = 0; c < DIMENSION; c++) {
                oceano[f][c] = EstadoCasilla.AGUA;
            }
        }
    }

    /**
     * Dibuja el tablero aplicando la lógica de ocultación.
     * @param revelarTodo Si es true, muestra los barcos (Game Over).
     */
    static void imprimirOceano(boolean revelarTodo) {
        System.out.println();

        // Eje de coordenadas X (Columnas)
        System.out.print("   ");
        for (int c = 0; c < DIMENSION; c++) {
            System.out.print(c + " ");
        }
        System.out.println();

        for (int f = 0; f < DIMENSION; f++) {
            System.out.print(f + "| "); // Eje de coordenadas Y (Filas)
            for (int c = 0; c < DIMENSION; c++) {
                EstadoCasilla actual = oceano[f][c];

                // LÓGICA DE NIEBLA DE GUERRA
                if (actual == EstadoCasilla.BARCO && !revelarTodo) {
                    // Si hay barco pero el juego sigue, ocultamos con agua
                    System.out.print(EstadoCasilla.AGUA + " ");
                } else {
                    // En cualquier otro caso, mostramos la realidad
                    System.out.print(actual + " ");
                }
            }
            System.out.println("|");
        }
    }

    /**
     * Lectura segura de enteros desde teclado.
     */
    static int pedirCoordenada(String mensaje) {
        int valor = NO_ENCONTRADO;
        boolean valido = false;

        while (!valido) {
            System.out.print(mensaje);
            if (teclado.hasNextInt()) {
                valor = teclado.nextInt();
                if (valor >= 0 && valor < DIMENSION) {
                    valido = true;
                } else {
                    System.out.println("Error: El número debe estar entre 0 y " + (DIMENSION - 1));
                }
            } else {
                teclado.next(); // Limpiar buffer de entrada errónea
                System.out.println("Error: Debes introducir un número entero.");
            }
        }
        return valor;
    }
}

Todo el código

import java.util.Random;
import java.util.Scanner;

/**
 * Juego de "Hundir la Flota" (Versión un jugador).
 * El objetivo es encontrar todos los barcos enemigos ocultos en el tablero
 * antes de que se agoten los intentos (misiles) disponibles.
 *
 * Este ejemplo refuerza el uso de matrices para ocultar información (niebla de guerra)
 * y la gestión de estados mediante Enums.
 */
public class Main {

    // --- ENUMS: CONFIGURACIÓN Y ESTÉTICA ---

    /**
     * Define los tipos de barcos y sus longitudes.
     */
    enum TipoBarco {
        PORTAAVIONES(5),
        ACORAZADO(4),
        CRUCERO(3),
        SUBMARINO(3),
        DESTRUCTOR(2);

        private final int longitud;

        TipoBarco(int longitud) {
            this.longitud = longitud;
        }

        public int getLongitud() {
            return longitud;
        }
    }

    /**
     * Enum que define los colores usando formato RGB (Red, Green, Blue).
     * Esto permite usar cualquier color de los 16 millones disponibles.
     */
    enum EstadoCasilla {
        // Símbolo y color en formato RGB
        AGUA     ( "~",      0, 180, 255),   // Azul cielo (agua)
        BARCO    ( "B",    160,  32, 240),   // Púrpura (barco sin impacto)
        TOCADO   ( "X",    255,   0,   0),   // Rojo puro (impacto)
        FALLO    ( "o",    180, 180, 180);   // Gris claro (fallo)

        private final String simbolo;
        private final String codigoColor;
        private static final String RESET = "\u001B[0m";

        /**
         * Constructor que acepta valores RGB (0-255).
         * Convierte los números a la secuencia ANSI TrueColor automáticamente.
         */
        EstadoCasilla(String simbolo, int r, int g, int b) {
            this.simbolo = simbolo;
            // La secuencia mágica para RGB es: \u001B[38;2;R;G;Bm
            this.codigoColor = String.format("\u001B[38;2;%d;%d;%dm", r, g, b);
        }

        @Override
        public String toString() {
            return codigoColor + simbolo + RESET;
        }
    }

    // --- CONSTANTES Y ESTADO GLOBAL ---

    static final int DIMENSION = 10;
    static final int NO_ENCONTRADO = -1;

    // Configuración de dificultad
    static final int MUNICION_MAXIMA = 50;
    static final int IMPACTOS_NECESARIOS = calcularPuntosTotales();

    // Matriz del tablero y herramientas
    static EstadoCasilla[][] oceano = new EstadoCasilla[DIMENSION][DIMENSION];
    static Scanner teclado = new Scanner(System.in);
    static Random radar = new Random();

    /**
     * Hilo principal de ejecución.
     * Gestiona el bucle de juego, el control de turnos y las condiciones de victoria/derrota.
     * @param args Argumentos de consola (no utilizados).
     */
    public static void main(String[] args) {
        System.out.println("--- HUNDIR LA FLOTA ---");
        System.out.println("Tablero: " + DIMENSION + "x" + DIMENSION);
        System.out.println("Regla especial: Los barcos no pueden tocarse entre sí.");
        System.out.println("Objetivo: " + IMPACTOS_NECESARIOS + " impactos.");
        System.out.println("Munición: " + MUNICION_MAXIMA + " misiles.");

        // 1. Preparación
        inicializarOceano();
        colocarFlotaCompleta();

        // 2. Variables de estado
        int aciertos = 0;
        int misilesRestantes = MUNICION_MAXIMA;
        boolean juegoTerminado = false;

        // 3. Bucle Principal
        while (!juegoTerminado) {
            imprimirOceano(false); // false = Modo Niebla de Guerra

            System.out.println("------------------------------------------------");
            System.out.println("Misiles: " + misilesRestantes + " | Aciertos: " + aciertos + "/" + IMPACTOS_NECESARIOS);

            // Turno de juego
            boolean impacto = realizarDisparo();
            misilesRestantes--;

            // Feedback inmediato
            if (impacto) {
                aciertos++;
                System.out.println(">>> ¡IMPACTO CONFIRMADO! <<<");
            } else {
                System.out.println(">>> Agua. Sin rastro del enemigo. <<<");
            }

            // Comprobación de fin de partida
            if (aciertos == IMPACTOS_NECESARIOS) {
                juegoTerminado = true;
                imprimirOceano(true); // Revelamos el mapa
                System.out.println("\n¡VICTORIA! Has desmantelado la flota enemiga.");

            } else if (misilesRestantes == 0) {
                juegoTerminado = true;
                imprimirOceano(true);
                System.out.println("\n¡MUNICIÓN AGOTADA! Retirada táctica.");
            }
        }
    }

    // --- LÓGICA DE JUEGO ---

    /**
     * Calcula dinámicamente cuántos aciertos hacen falta para ganar.
     * @return Total de casillas ocupadas por barcos.
     */
    static int calcularPuntosTotales() {
        int suma = 0;
        for (TipoBarco barco : TipoBarco.values()) {
            suma += barco.getLongitud();
        }
        return suma;
    }

    /**
     * Gestiona la interacción con el usuario para realizar un disparo.
     * Verifica que la coordenada sea válida y no se haya disparado antes allí.
     * @return true si el disparo acierta en un barco, false si falla.
     */
    static boolean realizarDisparo() {
        boolean disparoValido = false;
        int fila = NO_ENCONTRADO;
        int col = NO_ENCONTRADO;

        while (!disparoValido) {
            fila = pedirCoordenada("Fila (0-" + (DIMENSION - 1) + "): ");
            col = pedirCoordenada("Columna (0-" + (DIMENSION - 1) + "): ");

            if (oceano[fila][col] == EstadoCasilla.TOCADO || oceano[fila][col] == EstadoCasilla.FALLO) {
                System.out.println("Ya has disparado en esa zona. Elige otra.");
            } else {
                disparoValido = true;
            }
        }

        if (oceano[fila][col] == EstadoCasilla.BARCO) {
            oceano[fila][col] = EstadoCasilla.TOCADO;
            return true;
        } else {
            oceano[fila][col] = EstadoCasilla.FALLO;
            return false;
        }
    }

    // --- ALGORITMOS DE COLOCACIÓN (IA) ---

    /**
     * Recorre el catálogo de barcos y delega la colocación de cada uno.
     */
    static void colocarFlotaCompleta() {
        for (TipoBarco barco : TipoBarco.values()) {
            colocarBarcoAleatorio(barco);
        }
    }

    /**
     * Intenta colocar un barco en una posición aleatoria.
     * Si la posición elegida no es válida (choca, se toca con otro o se sale), repite el intento.
     * @param barco El tipo de barco a colocar.
     */
    static void colocarBarcoAleatorio(TipoBarco barco) {
        boolean colocado = false;

        while (!colocado) {
            int fila = radar.nextInt(DIMENSION);
            int col = radar.nextInt(DIMENSION);
            boolean horizontal = radar.nextBoolean();

            if (esPosicionValida(fila, col, barco.getLongitud(), horizontal)) {
                pintarBarcoEnMatriz(fila, col, barco.getLongitud(), horizontal);
                colocado = true;
            }
        }
    }

    /**
     * Verifica si el barco cabe y cumple la "Regla del Aire".
     * La regla del aire implica que no solo las casillas del barco deben estar libres,
     * sino también todas las casillas adyacentes (incluyendo diagonales).
     * @param f Fila inicial.
     * @param c Columna inicial.
     * @param longitud Tamaño del barco.
     * @param horizontal Orientación (true = horizontal, false = vertical).
     * @return true si el barco y su perímetro están libres.
     */
    static boolean esPosicionValida(int f, int c, int longitud, boolean horizontal) {
        // 1. Calculamos las dimensiones que ocupará el barco
        int anchoBarco = horizontal ? longitud : 1;
        int altoBarco  = horizontal ? 1 : longitud;

        // 2. Validar límites del tablero (Si se sale, devolvemos false)
        if (f + altoBarco > DIMENSION || c + anchoBarco > DIMENSION) {
            return false;
        }

        // 3. Definir el "Marco de Seguridad" (Barco + 1 casilla alrededor)
        // Usamos Math.max/min para no salirnos de los bordes (0 y 9)
        int filaInicio = Math.max(0, f - 1);
        int colInicio  = Math.max(0, c - 1);

        int filaFin = Math.min(DIMENSION - 1, f + altoBarco);
        int colFin  = Math.min(DIMENSION - 1, c + anchoBarco);

        // 4. Escanear esa área buscando obstáculos
        for (int i = filaInicio; i <= filaFin; i++) {
            for (int j = colInicio; j <= colFin; j++) {
                if (oceano[i][j] != EstadoCasilla.AGUA) {
                    return false; // Colisión detectada (barco o vecino)
                }
            }
        }

        return true; // Todo limpio
    }

    /**
     * Escribe el barco en la matriz una vez validada la posición.
     */
    static void pintarBarcoEnMatriz(int f, int c, int longitud, boolean horizontal) {
        for (int i = 0; i < longitud; i++) {
            if (horizontal) {
                oceano[f][c + i] = EstadoCasilla.BARCO;
            } else {
                oceano[f + i][c] = EstadoCasilla.BARCO;
            }
        }
    }

    // --- UTILIDADES Y VISTA ---

    /**
     * Limpia el tablero llenándolo de agua.
     */
    static void inicializarOceano() {
        for (int f = 0; f < DIMENSION; f++) {
            for (int c = 0; c < DIMENSION; c++) {
                oceano[f][c] = EstadoCasilla.AGUA;
            }
        }
    }

    /**
     * Dibuja el tablero en consola.
     * Utiliza la lógica de "Niebla de Guerra".
     * @param revelarTodo true para mostrar la ubicación de los barcos (Game Over).
     */
    static void imprimirOceano(boolean revelarTodo) {
        System.out.println();

        // Cabecera de columnas
        System.out.print("   ");
        for (int c = 0; c < DIMENSION; c++) {
            System.out.print(c + " ");
        }
        System.out.println();

        for (int f = 0; f < DIMENSION; f++) {
            System.out.print(f + "| "); // Índice de fila
            for (int c = 0; c < DIMENSION; c++) {
                EstadoCasilla actual = oceano[f][c];

                // Si es un barco y estamos jugando, lo mostramos como agua
                if (actual == EstadoCasilla.BARCO && !revelarTodo) {
                    System.out.print(EstadoCasilla.AGUA + " ");
                } else {
                    System.out.print(actual + " ");
                }
            }
            System.out.println("|");
        }
    }

    /**
     * Pide un número entero al usuario de forma segura.
     * @param mensaje Texto a mostrar.
     * @return Un entero validado dentro del rango del tablero.
     */
    static int pedirCoordenada(String mensaje) {
        int valor = NO_ENCONTRADO;
        boolean valido = false;

        while (!valido) {
            System.out.print(mensaje);
            if (teclado.hasNextInt()) {
                valor = teclado.nextInt();
                if (valor >= 0 && valor < DIMENSION) {
                    valido = true;
                } else {
                    System.out.println("Error: El número debe estar entre 0 y " + (DIMENSION - 1));
                }
            } else {
                teclado.next(); // Limpiar el buffer
                System.out.println("Error: Debes introducir un número entero.");
            }
        }
        return valor;
    }
}