0Pricing
Android Academy · Lección

Seguridad frente a valores nulos

Comprenda el sistema de seguridad frente a valores nulos de Kotlin: tipos anulables, el operador de llamada segura, el operador Elvis y cómo eliminar las NullPointerExceptions.

Seguridad frente a valores nulos 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.

El error de mil millones de dólares

En Java, cualquier variable puede ser null, lo que provoca una NullPointerException (NPE) durante la ejecución, uno de los errores más comunes en las aplicaciones de Android.

Tony Hoare, quien inventó null, lo llamó su error de mil millones de dólares.

Kotlin elimina las NPE durante la compilación mediante su sistema de seguridad frente a valores nulos.

Tipos anulables y no anulables

En Kotlin, los tipos son no anulables de forma predeterminada. Para permitir null, añada ? al tipo:

  • String — nunca es null, está garantizado
  • String? — puede ser null

El compilador lo impone: no permitirá asignar null a un tipo no anulable.

Ejemplo de tipos anulables

El compilador detecta los errores relacionados con valores nulos antes de ejecutar la aplicación:

fun main() {
    val name: String = "Alice"   // never null
    // name = null  // COMPILE ERROR

    var nickname: String? = "Al"  // nullable
    nickname = null               // OK

    println(name)
    println(nickname)  // null
}

Operador de llamada segura ?.

El operador de llamada segura ?. llama a un método solo si el objeto no es nulo. Si es nulo, devuelve null en lugar de provocar un error.

nickname?.length → devuelve la longitud o null si nickname es null.

Llamadas seguras en acción

Use ?. para acceder de forma segura a propiedades anulables:

fun main() {
    var text: String? = "Hello"
    println(text?.length)   // 5
    println(text?.uppercase()) // HELLO

    text = null
    println(text?.length)   // null (no crash!)
    println(text?.uppercase()) // null
}

Operador Elvis ?:

El operador Elvis ?: proporciona un valor predeterminado cuando una expresión es null:

val len = text?.length ?: 0

Se puede leer así: «la longitud de text o 0 si text es null».

Recibe su nombre del emoji de Elvis 🕺, cuyo cabello se parece a ?:.

Ejemplo del operador Elvis

Proporcione valores predeterminados seguros con ?::

fun main() {
    var name: String? = "Bob"
    println(name?.length ?: 0)  // 3

    name = null
    println(name?.length ?: 0)  // 0

    val display = name ?: "Anonymous"
    println(display)  // Anonymous
}

Comprobaciones de valores nulos con if

Dentro de un bloque if (x != null), Kotlin convierte automáticamente mediante smart cast el tipo anulable en no anulable; no necesita usar ?. dentro del bloque.

Ejemplo de smart cast

Kotlin restringe el tipo después de una comprobación de valor nulo:

fun printLength(text: String?) {
    if (text != null) {
        // 'text' is now String (non-nullable) here
        println("Length: ${text.length}") // no ?. needed
    } else {
        println("text is null")
    }
}

fun main() {
    printLength("Kotlin")  // Length: 6
    printLength(null)       // text is null
}

Comprobación rápida

¿A qué valor se evalúa null?.length ?: -1?

Resumen: seguridad frente a valores nulos

El sistema de seguridad frente a valores nulos de Kotlin elimina las NPE:

  • Los tipos son no anulables de forma predeterminada; añada ? para permitir null
  • ?., llamada segura: devuelve null en lugar de provocar un error
  • ?:, operador Elvis: proporciona un valor predeterminado cuando el valor es nulo
  • Smart casts dentro de bloques if (x != null)

A continuación: estructurará el código con clases y objetos.

Preguntas frecuentes

¿La lección «Seguridad frente a valores nulos» es gratis?

Sí — el texto completo de «Seguridad frente a valores nulos» 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 «Seguridad frente a valores nulos»?

Comprenda el sistema de seguridad frente a valores nulos de Kotlin: tipos anulables, el operador de llamada segura, el operador Elvis y cómo eliminar las NullPointerExceptions. 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 «Seguridad frente a valores nulos»?

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

  1. Seguridad frente a valores nulos
  2. Clases y objetos
  3. Clases de datos y clases selladas
  4. Funciones de extensión y de orden superior
← Volver a Android Academy