¿Por qué Java tiene una "NullPointerException" cuando no hay punteros en Java?

Question

¿Por qué recibo una excepción llamada NullPointerException si en Java no existe el concepto de puntero?

Answer 1

Sí, esta es una de las primeras cosas molestas que aprendí al aprender Java LOL. Realmente debería llamarse NullReferenceException, NoObjectException o DereferenceException como se menciona paxdiablo. Las referencias ni siquiera tienen que representarse internamente como punteros y no debería tener que preocuparse. "La mayoría de las máquinas virtuales, incluidos los identificadores de uso de Sun, no los punteros. Un identificador es un puntero a un puntero, así que ¿quién sabe cómo se les ocurrió usar eso?" Oh Java VM de Microsoft realmente usa punteros en lugar de identificadores, así que imagínate.

Answer 2

No hay punteros de propósito general en Java, que puede manipular fácilmente agregando y restando valores arbitrarios como en C. Esto puede conducir a todo tipo de problemas para los que no se utilizan para ellos.

Sin embargo, Java aún necesita distinguir entre un objeto y "ningún objeto". Es solo el nombre de la excepción que significa que está tratando de usar una referencia de objeto que no tiene un objeto de respaldo detrás de ella.

Podrías llamarlo NoObjectException o DereferenceException, o uno entre una miríada de otros nombres para minimizar la posibilidad de que la gente piense que Java tiene punteros de propósito general.

Pero NullPointerException es lo que los creadores de idiomas eligieron, probablemente porque estaban acostumbrados a codificar en C y/o C++.

Answer 3

Técnicamente eso es correcto, lo que realmente debería ser llamado NullReferenceException

Answer 4

Debido a que internamente las variables de objeto son punteros a esos objetos. Sin embargo, no obtiene el valor del puntero excepto llamando a System.identityHashCode (object) en la mayoría de las implementaciones de JVM, que devuelve el puntero al objeto.

EDITAR: Estás casi bien, estaba casi equivocado: identityHashCode es mucho más complejo que devolver solo un puntero. Solo eché un vistazo a la fuente de JVM e implementaron algunos generadores de código hash. Sin embargo, al menos en el caso en que hashCode (una constante? No lo sé) es una constante, devuelven el puntero del objeto. Aquí es su fuente para los curiosos:

static inline intptr_t get_next_hash(Thread * Self, oop obj) { 
    intptr_t value = 0 ; 
    if (hashCode == 0) { 
    // This form uses an unguarded global Park-Miller RNG, 
    // so it's possible for two threads to race and generate the same RNG. 
    // On MP system we'll have lots of RW access to a global, so the 
    // mechanism induces lots of coherency traffic. 
    value = os::random() ; 
    } else 
    if (hashCode == 1) { 
    // This variation has the property of being stable (idempotent) 
    // between STW operations. This can be useful in some of the 1-0 
    // synchronization schemes. 
    intptr_t addrBits = intptr_t(obj) >> 3 ; 
    value = addrBits^(addrBits >> 5)^GVars.stwRandom ; 
    } else 
    if (hashCode == 2) { 
    value = 1 ;   // for sensitivity testing 
    } else 
    if (hashCode == 3) { 
    value = ++GVars.hcSequence ; 
    } else 
    if (hashCode == 4) { 
    value = intptr_t(obj) ; 
    } else { 
    // Marsaglia's xor-shift scheme with thread-specific state 
    // This is probably the best overall implementation -- we'll 
    // likely make this the default in future releases. 
    unsigned t = Self->_hashStateX ; 
    t ^= (t << 11) ; 
    Self->_hashStateX = Self->_hashStateY ; 
    Self->_hashStateY = Self->_hashStateZ ; 
    Self->_hashStateZ = Self->_hashStateW ; 
    unsigned v = Self->_hashStateW ; 
    v = (v^(v >> 19))^(t^(t >> 8)) ; 
    Self->_hashStateW = v ; 
    value = v ; 
    } 

    value &= markOopDesc::hash_mask; 
    if (value == 0) value = 0xBAD ; 
    assert (value != markOopDesc::no_hash, "invariant") ; 
    TEVENT (hashCode: GENERATE) ; 
    return value; 
} 

Answer 5

Si usted tiene un objeto con digamos una lista como un atributo y no asigna explícitamente espacio para ello, el programa que se ejecuta le tirar ese error.

Busque en un depurador (Eclipse o no) para ver qué objetos tienen cuando no los inicializa correctamente y entonces las cosas van a quedar bastante claras.

Creo que se hizo para que haya una noción entre el objeto que tiene espacio en la memoria y el que no.

Answer 6

Porque todas las variables (en RHS de asignación) que declara son referencias a algunos objetos en el espacio de montón. Si una referencia no está apuntando a ningún lado, entonces al acceder a esa variable arroja nullpointereception.