Android Academy · Lección

Tipos anulables frente a no anulables

El marcador de tipo ?

Tipos anulables frente a no anulables es una lección gratuita de Android 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 Android Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Android Academy incluye 4 lecciones en total.

Por qué es importante la seguridad frente a nulos

Muchos fallos en las aplicaciones Android se deben a un único error: usar un valor que en realidad falta. En otros lenguajes, esto se convierte en una temida NullPointerException durante la ejecución.

Kotlin aborda este problema en tiempo de compilación. El sistema de tipos realiza un seguimiento de qué valores pueden ser null y cuáles no. Esta lección presenta los fundamentos de ese sistema.

Tipos no nulos

De forma predeterminada, un tipo de Kotlin no puede contener null. Un String siempre apunta a una cadena real.

Si intenta asignarle null, el código ni siquiera se compilará. Este es el comportamiento seguro predeterminado.

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

null se rechaza

Observe qué ocurre cuando intenta introducir null en un tipo no nulo.

El compilador se lo impide de inmediato. Nunca llegará al tiempo de ejecución con un error oculto.

val name: String = null  // Compile error:
// Null can not be a value of a non-null type String

Tipos anulables con ?

A veces un valor puede faltar realmente, como el segundo nombre opcional de un usuario. Para indicarlo, añada ? al tipo.

Un String? puede contener una cadena real o null. El signo de interrogación marca el tipo como anulable.

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

Dos tipos diferentes

String y String? no son el mismo tipo. El segundo es un tipo más amplio que incluye el valor null.

Esta distinción permite que el compilador le proteja. Sabe exactamente dónde puede aparecer null.

val sure: String = "hello"
val maybe: String? = "hello"
// maybe could later be null; sure never can

No puede usar directamente un tipo anulable

El compilador no le permitirá llamar a un método sobre un valor anulable sin comprobarlo antes.

Como middleName podría ser null, llamar a .length sobre él provoca un error de compilación. Debe gestionar el caso nulo.

val middleName: String? = null
println(middleName.length)
// Error: only safe (?.) or non-null (!!) calls allowed

Comprobar con if

La forma más sencilla de usar un valor anulable es comprobarlo con una condición if.

Dentro de la rama en la que ha demostrado que no es nulo, Kotlin aplica una conversión inteligente a un tipo no nulo, por lo que .length funciona.

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

Conversiones inteligentes

Después de comprobar correctamente que un valor no es nulo, el compilador recuerda que no lo es durante el resto de ese bloque. Esto se denomina conversión inteligente.

No ha escrito ninguna conversión. Kotlin la realiza automáticamente por usted.

fun describe(s: String?) {
    if (s == null) return
    // s is now treated as String here
    println("Length is " + s.length)
}

Parámetros de funciones

Que un parámetro sea anulable forma parte del contrato de la función. Un parámetro no nulo garantiza a quienes llaman a la función que nunca recibirá null.

Un parámetro anulable indica que se espera que falte la entrada y que ese caso se gestiona.

fun greet(name: String) {
    println("Hi, " + name)
}
// greet(null) would not compile

Los tipos de retorno pueden ser anulables

Una función puede devolver null para indicar que no se encontró nada. Marque su tipo de retorno con ?.

Así, quienes llamen a la función sabrán que deben comprobar el resultado antes de usarlo.

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

Use tipos no nulos de forma predeterminada

Una buena regla es preferir los tipos no nulos. Añada ? únicamente cuando un valor pueda faltar de verdad.

Esto mantiene la honestidad del código. Cuantos menos tipos anulables tenga, menos comprobaciones de nulos necesitará después.

// Prefer this:
val score: Int = 0
// Over this, unless null is meaningful:
val maybeScore: Int? = null

Comprobación rápida

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

Recapitulación

Los tipos de Kotlin no son nulos de forma predeterminada y rechazan null en tiempo de compilación. Añada ? para hacer que un tipo sea anulable cuando pueda faltar un valor.

No puede usar directamente un valor anulable. Una comprobación de nulos aplica una conversión inteligente a no nulo para que pueda usarlo de forma segura. A continuación aprenderá formas más breves de gestionar valores anulables.

Preguntas frecuentes

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

Sí — el texto completo de «Tipos anulables frente a 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 Android Academy, actualiza a CoddyKit PRO. El curso de Android Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Tipos anulables frente a no anulables»?

El marcador de tipo ? Practicas Android 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 Android Academy?

No se requiere experiencia previa. Android 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 frente a 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 Android Academy?

Sí. Cada lección de Android 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 Android Academy