Sin excepción al escribir con un valor nulo en Java

String x = (String) null;

¿Por qué no hay excepción en esta declaración?

String x = null;
System.out.println(x);

Se imprime null. Pero el .toString()método debería arrojar una excepción de puntero nulo.

Puede emitir nulla cualquier tipo de referencia sin obtener ninguna excepción.

El printlnmétodo no arroja un puntero nulo porque primero verifica si el objeto es nulo o no. Si es nulo, simplemente imprime la cadena "null". De lo contrario, llamará al toStringmétodo de ese objeto.

Agregar más detalles: métodos de impresión internamente llaman String.valueOf(object)método en el objeto de entrada. Y en el valueOfmétodo, esta comprobación ayuda a evitar una excepción de puntero nulo:

return (obj == null) ? "null" : obj.toString();

Para el resto de su confusión, llamar a cualquier método en un objeto nulo debería arrojar una excepción de puntero nulo, si no un caso especial.

Puede emitir nulla cualquier tipo de referencia. También puede llamar a métodos que manejan a nullcomo argumento, por ejemplo, System.out.println(Object)sí, pero no puede hacer referencia a un nullvalor y llamar a un método sobre él.

Por cierto, hay una situación difícil en la que parece que puede llamar a métodos estáticos en los nullvalores.

Thread t = null;
t.yield(); // Calls static method Thread.yield() so this runs fine.

Esto es por diseño. Puede emitir nulla cualquier tipo de referencia. De lo contrario, no podría asignarlo a variables de referencia.

La conversión de valores nulos es necesaria para la siguiente construcción donde un método está sobrecargado y si se pasa nulo a estos métodos sobrecargados, entonces el compilador no sabe cómo aclarar la ambigüedad, por lo tanto, necesitamos escribir nulo en estos casos:

class A {
  public void foo(Long l) {
    // do something with l
  }
  public void foo(String s) {
    // do something with s      
  }
}
new A().foo((String)null);
new A().foo((Long)null);

De lo contrario, no podría llamar al método que necesita.

Println(Object) usos String.valueOf()

public static String valueOf(Object obj) {
    return (obj == null) ? "null" : obj.toString();
}

Print(String) hace cheque nulo.

public void print(String s) {
    if (s == null) {
        s = "null";
    }
    write(s);
}

Muchas respuestas aquí ya mencionan

Puede convertir nulo a cualquier tipo de referencia

y

Si el argumento es nulo, entonces una cadena igual a "nulo"

Me pregunté dónde se especifica eso y busqué la especificación Java:

La referencia nula siempre se puede asignar o emitir a cualquier tipo de referencia (§5.2, §5.3, §5.5).

Si la referencia es nula, se convierte en la cadena "nulo" (cuatro caracteres ASCII n, u, l, l).

Como otros han escrito, puede lanzar nulo a todo. Normalmente, no necesitarías eso, puedes escribir:

String nullString = null;

sin poner el elenco allí.

Pero hay ocasiones en que tales elencos tienen sentido:

a) si desea asegurarse de que se llame a un método específico, como:

void foo(String bar) {  ... }
void foo(Object bar) {  ... }

entonces haría una diferencia si escribes

foo((String) null) vs. foo(null)

b) si tiene la intención de usar su IDE para generar código; por ejemplo, normalmente escribo pruebas unitarias como:

@Test(expected=NullPointerException.class)
public testCtorWithNullWhatever() {
    new MyClassUnderTest((Whatever) null);
}

Estoy haciendo TDD; Esto significa que la clase "MyClassUnderTest" probablemente todavía no existe. Al escribir ese código, puedo usar mi IDE para generar primero la nueva clase; y luego generar un constructor que acepte un argumento "Lo que sea" "listo para usar": el IDE puede deducir de mi prueba que el constructor debe tomar exactamente un argumento de tipo Whatever.

Imprimir :

Imprime un objeto. La cadena producida por el método String.valueOf (Object) se traduce a bytes

Valor de :

si el argumento es nulo, entonces una cadena igual a "nulo"; de lo contrario, se devuelve el valor de obj.toString ().

Simplemente devolverá una cadena con el valor "nulo" cuando el objeto lo sea null.

Esto es muy útil cuando se usa un método que de otra manera sería ambiguo. Por ejemplo: JDialog tiene constructores con las siguientes firmas:

JDialog(Frame, String, boolean, GraphicsConfiguration)
JDialog(Dialog, String, boolean, GraphicsConfiguration)

Necesito usar este constructor, porque quiero configurar GraphicsConfiguration, pero no tengo padre para este diálogo, por lo que el primer argumento debería ser nulo. Utilizando

JDialog(null, String, boolean, Graphicsconfiguration) 

es ambiguo, por lo que en este caso puedo reducir la llamada al convertir nulo en uno de los tipos admitidos:

JDialog((Frame) null, String, boolean, GraphicsConfiguration)

Esta característica del lenguaje es conveniente en esta situación.

public String getName() {
  return (String) memberHashMap.get("Name");
}

Si memberHashMap.get ("Nombre") devuelve nulo, aún querría que el método anterior devuelva nulo sin lanzar una excepción. No importa cuál sea la clase, nulo es nulo.