Kotlin Academy · Lección

Tipos anulables y no anulables

Conceptos básicos del sistema de tipos

Tipos anulables y no anulables es una lección gratuita de Kotlin Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Kotlin Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Kotlin Academy incluye 4 lecciones en total.

Por qué es importante la seguridad frente a null

La infame NullPointerException ha provocado el fallo de innumerables programas. Kotlin aborda este problema directamente al convertir la nulabilidad en parte del sistema de tipos.

En Kotlin, el compilador sabe si un valor puede ser null o no, y le obliga a gestionar esa posibilidad antes de que cause problemas.

Tipos no nulos

De forma predeterminada, todos los tipos de Kotlin son no nulos. Una variable de tipo String nunca puede contener null.

Esta garantía se comprueba en tiempo de compilación, por lo que puede usar el valor libremente sin comprobaciones.

fun main() {
    val name: String = "Alice"
    println(name.length)
}

Se rechaza la asignación de null

Si intenta asignar null a un tipo no nulo, el compilador se lo impide de inmediato.

La línea siguiente no se compilaría porque String no acepta null:

val name: String = null → error

fun main() {
    val city: String = "Paris"
    // val broken: String = null // compile error
    println(city)
}

Tipos anulables

Para permitir null, añada un signo de interrogación después del tipo: String?.

Este es un tipo anulable. Puede contener un valor real o null.

fun main() {
    val maybeName: String? = null
    println(maybeName)
}

Anulables frente a no nulos

Las dos declaraciones parecen casi idénticas, pero se comportan de forma muy diferente:

val a: String → nunca es null
val b: String? → podría ser null

Un solo ? cambia por completo el contrato de la variable.

fun main() {
    val a: String = "hi"
    val b: String? = "hi"
    println(a)
    println(b)
}

El compilador protege el acceso a valores anulables

No puede llamar directamente a métodos de un valor anulable. El compilador lo impide porque el valor podría ser null.

La línea comentada siguiente no se compilaría:

maybe.length sobre un String? → error

fun main() {
    val maybe: String? = "text"
    // println(maybe.length) // compile error
    println(maybe)
}

Comprobación de null

Una forma sencilla de usar un valor anulable consiste en realizar una comprobación explícita con if.

Dentro del bloque if, Kotlin sabe que el valor no es null y le permite usarlo de forma segura.

fun main() {
    val maybe: String? = "hello"
    if (maybe != null) {
        println(maybe.length)
    }
}

Null en los parámetros de funciones

Los tipos de los parámetros también siguen esta regla. Un parámetro de tipo String debe recibir un valor real, mientras que String? acepta null.

Esto hace que las firmas de las funciones documenten por sí mismas qué valores aceptan.

fun greet(name: String?) {
    if (name != null) {
        println("Hello, " + name)
    } else {
        println("Hello, guest")
    }
}

fun main() {
    greet("Mia")
    greet(null)
}

Tipos de retorno anulables

Las funciones pueden devolver tipos anulables para expresar que puede faltar un resultado.

El código que realiza la llamada debe gestionar el posible null antes de usar el resultado.

fun firstChar(text: String?): Char? {
    if (text == null || text.isEmpty()) return null
    return text[0]
}

fun main() {
    println(firstChar("Kotlin"))
    println(firstChar(null))
}

Inferencia predeterminada

Cuando asigna un literal, Kotlin infiere automáticamente un tipo no nulo.

val n = "text" → se infiere String

Para hacerlo anulable, debe declarar explícitamente el tipo con ?.

fun main() {
    val n = "text" // inferred String (non-null)
    val m: String? = "text" // explicit nullable
    println(n.length)
    println(m)
}

Unificación de conceptos

El sistema de tipos divide los valores en dos grupos claros:

No nulos: siempre es seguro usarlos
Anulables: deben gestionarse antes de usarlos

Esta distinción convierte los errores relacionados con null en errores de compilación en lugar de fallos en tiempo de ejecución.

fun main() {
    val safe: String = "always here"
    val risky: String? = null
    println(safe.uppercase())
    if (risky != null) println(risky.uppercase()) else println("no value")
}

Comprobación rápida

Compruebe su comprensión de los tipos anulables y no nulos.

Resumen

Ha aprendido los fundamentos de la seguridad frente a null en Kotlin:

Todos los tipos son no nulos de forma predeterminada
Añadir ? crea un tipo anulable
El compilador bloquea el acceso no seguro a los valores anulables
Una comprobación if (x != null) permite usar el valor de forma segura

A continuación aprenderá los operadores concisos que facilitan el trabajo con valores anulables.

Preguntas frecuentes

¿La lección «Tipos anulables y no anulables» es gratis?

Sí — el texto completo de «Tipos anulables y no anulables» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Kotlin Academy, actualiza a CoddyKit PRO. El curso de Kotlin Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Tipos anulables y no anulables»?

Conceptos básicos del sistema de tipos Practicas Kotlin Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Kotlin Academy?

No se requiere experiencia previa. Kotlin Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «Tipos anulables y no anulables»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Kotlin Academy?

Sí. Cada lección de Kotlin Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Kotlin Academy