✨ Valor `null` en Java

🧩 ¿Qué es `null`?

En Java, null representa la ausencia de un objeto.
No es una cadena vacía, no es cero, no es “nada”: es la referencia que indica que no hay ninguna instancia creada.

String nombre = null; // la variable existe, pero no apunta a ningún objeto

nullValue

El objeto Persona con el nombre de Patricia se destruirá eventualmente por el garbage collector ya que no es referenciado por nadie.

❗ NullPointerException (NPE)

Ocurre cuando intentas usar un método o atributo sobre una variable que es null.

String nombre = null;
int longitud = nombre.length(); // ❌ NPE

✔ Cómo evitar NPE

Comprobar antes de usar:

if (nombre != null) {
    System.out.println(nombre.length());
}

Inicializar siempre las variables.
Usar valores por defecto razonables.
Evitar devolver null si puedes devolver algo útil.

⚠ `null` NO es lo mismo que:

Valor	Significa
`""`	Cadena vacía
`0`	Número cero
`" "`	Espacio en blanco
`false`	Boolean falso

🧠 ¿Cuándo se usa `null`?

Para indicar que un objeto no se ha creado aún.
Para variables de instancia invisibles hasta que el constructor las inicializa.
Para valores opcionales.

📦 Autoboxing y Unboxing en Java: El Peligro del `null`

🔹 ¿Qué es autoboxing?

El autoboxing es el proceso automático mediante el cual Java convierte un tipo primitivo en su clase envolvente (wrapper) correspondiente.

Ejemplo:

int n = 5;
Integer x = n;   // autoboxing: de int → Integer

Java realiza esta conversión sin que el programador tenga que escribir código explícito.

🔹 ¿Qué es unboxing?

El unboxing es el proceso inverso: Java convierte un wrapper en su tipo primitivo.

Ejemplo:

Integer x = 10;
int n = x;   // unboxing: de Integer → int

🔹 ¿Qué relación tiene esto con `null`?

Las clases envolventes (como Integer, Double, Boolean, etc.) pueden ser null.
Los tipos primitivos (int, double, boolean…) no pueden ser null.

Esto provoca un riesgo importante:

❗ NullPointerException por unboxing

Integer x = null;
int n = x;   // ERROR: NullPointerException

El programa intenta convertir un wrapper null a un primitivo, lo cual es imposible.

🔹 ¿Cuándo puede ocurrir este error sin darnos cuenta?

Muy fácilmente:

Al devolver wrappers desde métodos que pueden devolver null
Al usar colecciones que almacenan wrappers
Al asignar wrappers a primitivos mediante unboxing implícito
Al usar comparaciones con operadores >, <, == sobre wrappers

Ejemplo peligroso:

Integer edad = obtenerEdad(); // puede ser null
if (edad > 18) {              // unboxing automático
    ...
}

Si edad es null → ❌ NullPointerException.

🌟 Buenas prácticas

Evita null en colecciones (cuando las veáis más adelante).
Usa nombres descriptivos y estados por defecto.
Si un atributo es obligatorio, nunca permitas null en él.
✔️ Usar tipos primitivos cuando sepamos que nunca habrá null

✨ Valor null en Java

🧩 ¿Qué es null?