Comparación de dos objetos nulos a partir de dos tipos diferentes

Question

public void m1(Integer f) { 
    ... 
} 

public void m1(Float f) { 
    ... 
} 

public void main() { 
    m1(null); // error: the method m1(Integer) is ambiguous for the type Main 
    m1((Integer) null); // success 
} 

dado el ejemplo anterior, se puede admitir de alguna manera que null se escribe. Entonces, ¿por qué las siguientes líneas imprimen true? Claro o1 y o2 ambos no tienen ningún valor (es decir, null), pero no son del mismo tipo (Integer vs Float). Primero pensé que false habría sido impreso.

Integer i = null; 
Object o1 = (Object) i; 
Float f = null; 
Object o2 = (Object) f; 
System.out.println(o1 == o2); // prints true 

// in short: 
System.out.println(((Object) ((Integer) null)) == ((Object) ((Float) null))); // prints true 

Answer 1

Todo null valores son sin tipo y son iguales. Puede pasarlo a diferentes tipos de referencia, pero no tiene importancia a efectos comparativos.

No es el valor null que se tipea sino la referencia al nulo que se puede tipear.

Una pregunta común es lo que sucede aquí

class A { 
    public static void hello() { System.out.println("Hello World"); } 

    public static void main(String... args) { 
     A a = null; 
     a.hello(); 
     System.out.println("a is an A is " + (a instanceof A)); // prints false. 
    } 
} 

El compilador ve el tipo de a como A por lo que el método estático se llama. Pero el valor al que se hace referencia es null y sin tipo.

Las únicas operaciones que puede realizar con null sin causar una excepción NullPointerException es asignarlas o pasarlas sin examinarlas o compararlas con otra referencia.

BTW

En resumen: El compilador seleccionará un método basado en el tipo de la referencia, en tiempo de ejecución de la ejecución se basa en la clase del objeto de referencia. En tiempo de ejecución, null se trata como cualquier tipo o no, o se obtiene una NullPointerException si se intenta desreferenciarla.

Answer 2

"==" en Java comprueba si es la misma instancia en lugar de simplemente "¿son iguales?". No existe el concepto de múltiples instancias de nulo en Java. Si compara null a null, siempre recibirá verdadero independientemente del tipo.

La razón por la que no se puede pasar nulo como argumento a un método con el mismo nombre que otro con diferentes tipos de parámetros es porque cualquiera de los métodos podría ser un candidato para llamar sin otro tipo de contexto. En lugar de adivinar cuál podría ser, indica correctamente un error.

Answer 3

Dado el ejemplo anterior, podemos admitir que null NO está tipeado: cuando llama al m1(null), el compilador no puede determinar el tipo del parámetro real y no puede decidir qué método invocar. Todos los nulos son iguales y no se escriben, por lo que (null==null)==true.

Answer 4

Null no tiene un tipo, pero una referencia (a null o cualquier otra cosa) tiene un tipo.Podemos declarar dos variables de referencia con diferentes tipos, pero la null se refieren es el mismo en ambos casos:

Integer a = null; 
Double b = null; 

En su ejemplo,

m1((Integer) null); 

el compilador utiliza el tipo de la la referencia se pasa para determinar qué método sobrecargado llamar, no el tipo del valor null mismo.

Answer 5

En su ejemplo, prueba que el compilador no puede identificar el tipo (de nulo) y decidir qué método llamar. Entonces debes explicitar el tipo. También null == null será siempre verdadero; no importa el lanzamiento que hagas, no cambia ni da un tipo nulo.

Este post tiene una descripción larga en null.

Answer 6

ver http://docs.oracle.com/javase/specs/jls/se7/html/jls-4.html#jls-4.1

null pertenece al "tipo nulo". El "tipo nulo" tiene solo un valor: el null.

El tipo nulo es un subtipo de cada tipo de referencia. Por lo tanto podemos hacer

Integer i = null; 
(Integer)null 

En otra palabra, null es un valor válido en todos los tipos de referencia.

(Piense de un tipo como un conjunto de valores; los tipos de un valor es los conjuntos que pertenece; "subtipo" significa "subconjunto".)