Introducción a la Seguridad contra Nulos

La gestión de valores nulos representa uno de los desafíos más comunes en desarrollo de software. Kotlin aborda este problema mediatne un sistema de tipos robusto que previene errores de puntero nulo en tiempo de compilación. Este tutorial profundiza en las herramientas fundamentales que hacen que tu código sea más resiliente.

Tiempo estimado: 2 días de estudio práctico.

Metas de Aprendizaje

• Diferenciar entre tipos anulables y no anulables
• Aplicar el operador de llamada segura ?. en objetos complejos
• Implementar valores de respaldo con el operador Elvis ?:
• Comprender los riesgos de la aserción !!
• Aprovechar las conversiones inteligentes de tipos mediante if
• Construir funciones con parámetros y retornos anulables

Día 1: Tipos Anulables y Acceso Seguro

El Problema de los Valores Nulos

Los errores por valores nulos son una fuente constante de fallos en tiempo de ejecución. Cuando una variable que debería contener datos aparece como null, cualquier operación sobre ella provoca un colapso inmediato. Kotlin elimina esta vulnerabilidad mediante verificaciones estáticas.

Tipos No Anulables por Defecto

En Kotlin, todas las variables son no anulables a menos que se especifique lo contrario. Esto significa que no pueden contener valores null.

fun principal() {
    val lenguaje: String = "Kotlin"
    println(lenguaje.uppercase())
}

El siguiente código genera un error de compilación:

fun principal() {
    val lenguaje: String = null // Fallo en compilación
}

Declarando Tipos Anulables

Para permitir valores nulos, añade el símbolo ? después del tipo.

fun principal() {
    val lenguaje: String? = null
    println(lenguaje)
}

La diferencia es fundamental:

Tipo	Admite nulos
String	No
String?	Sí
Int	No
Int?	Sí

Restricción de Acceso Directo

No puedes invocar métodos o propiedades directamente sobre un tipo anulable:

fun principal() {
    val texto: String? = null
    println(texto.length) // Error de compilación
}

Operador de Llamada Segura ?.

El operador ?. permite acceder a miembros de forma segura, devolviendo null si el receptor es nulo.

fun principal() {
    val mensaje: String? = null
    println(mensaje?.length) // Imprime null sin crash
}

Cuando el valor existe:

fun principal() {
    val mensaje: String? = "Hola Mundo"
    println(mensaje?.length) // Imprime 10
}

Encadenamiento de Accesos Seguros

Para estructuras anidadas, concatena múltiples operadores ?.:

data class Ubicacion(val pais: String)
data class Perfil(val alias: String, val residencia: Ubicacion?)

fun principal() {
    val perfil = Perfil("María", null)
    val paisOrigen = perfil.residencia?.pais
    
    println(paisOrigen) // Imprime null
}

Ejercicios del Día 1

1. Crea una variable String? con valores null y "Desarrollo", verifica el comportamiento de ?.
2. Implementa mostrarLongitud(texto: String?) que imprima la longitud de forma segura.
3. Define clases Empleado y Departamento para acceder al nombre del departamento mediante ?.

Solución propuesta:

data class Departamento(val nombre: String)
data class Empleado(val nombre: String, val departamento: Departamento?)

fun mostrarLongitud(texto: String?) {
    println("Tamaño: ${texto?.length ?: 0}")
}

fun principal() {
    mostrarLongitud(null)
    mostrarLongitud("Kotlin")
    
    val empleado = Empleado("Juan", null)
    println(empleado.departamento?.nombre)
}

Día 2: Valores por Defecto, Aserciones y Conversiones Inteligentes

Operador Elvis ?:

Proporciona un valor alternativo cuando la expresión izquierda evalúa a null.

fun principal() {
    val entrada: String? = null
    val valorFinal = entrada ?: "Valor predeterminado"
    
    println(valorFinal)
}

Combinado con llamadas seguras:

fun principal() {
    val cadena: String? = null
    val longitud = cadena?.length ?: 0
    
    println(longitud) // Imprime 0
}

Aserción No Nula !!

La doble exclamación fuerza el desempaquetado, asumiendo que el valor nunca será nulo.

fun principal() {
    val codigo: String? = "ABC123"
    println(codigo!!.length) // Funciona correctamente
}

Si la suposición es incorrecta, la aplicación terminará abruptamente:

fun principal() {
    val codigo: String? = null
    println(codigo!!.length) // NullPointerException en tiempo de ejecución
}

Regla de oro: Evita !! en producción. Existen alternativas más seguras.

Conversión Inteligente de Tipos

Después de verificar que una variable no es nula, el compilador la trata como tipo no anulable automáticamente.

fun principal() {
    val identificador: String? = "ID-456"
    
    if (identificador != null) {
        println(identificador.length) // No requiere ?. aquí
    }
}

Parámetros Anulables en Funciones

fun procesarEtiqueta(etiqueta: String?): String {
    return etiqueta ?: "Sin etiqueta"
}

fun principal() {
    println(procesarEtiqueta(null))
    println(procesarEtiqueta("Urgente"))
}

Retornos Anulables

fun buscarProducto(sku: Int): String? {
    return if (sku > 0) "Producto-$sku" else null
}

fun principal() {
    val resultado = buscarProducto(-5)
    println(resultado ?: "Producto no encontrado")
}

Ejercicios Integrados

Ejercicio 1: Normalización de Nombres

Crea una función que devuelva "Usuario Anónimo" para valores nulos:

fun normalizarNombre(apodo: String?): String {
    return apodo ?: "Usuario Anónimo"
}

fun principal() {
    println(normalizarNombre(null))
    println(normalizarNombre("Ana"))
}

Ejercicio 2: Cálculo de Caracteres

fun calcularCaracteres(frase: String?): Int {
    return frase?.length ?: 0
}

fun principal() {
    println(calcularCaracteres(null))
    println(calcularCaracteres("Android"))
}

Ejercicio 3: Resolución de Ubicación

data class Coordenada(val latitud: Double, val longitud: Double)
data class PuntoInteres(val titulo: String, val coordenada: Coordenada?)

fun obtenerCoordenada(punto: PuntoInteres?): String {
    val lat = punto?.coordenada?.latitud ?: 0.0
    val lon = punto?.coordenada?.longitud ?: 0.0
    return "Lat: $lat, Lon: $lon"
}

fun principal() {
    val lugar1 = PuntoInteres("Museo", Coordenada(40.4, -3.7))
    val lugar2 = PuntoInteres("Hotel", null)
    
    println(obtenerCoordenada(lugar1))
    println(obtenerCoordenada(lugar2))
    println(obtenerCoordenada(null))
}

Errores Frecuentes y Soluciones

Error 1: Acceso Directo a Propiedades Anulables

val dato: String? = null
println(dato.length) // INCORRECTO

Corrección:

println(dato?.length)

Error 2: Uso Indiscriminado de !!

val opcional: String? = null
println(opcional!!.length) // PELIGROSO

Alternativa segura:

println(opcional?.length ?: 0)

Cuestionario de Repaso

1. ¿Qué distingue a String de String? en el sistema de tipos?
2. ¿Cuál es el comportamiento del operador ?. cuando el receptor es nulo?
3. Describe un escenario práctico para aplicar el operador Elvis.
4. ¿Por qué las aserciones !! comprometen la estabilidad de la aplicación?
5. Explica cómo funciona la conversión inteligente dentro de bloques condicionales.