Llamada explícita vs implícita de toString

Question

Solía ??usar la llamada implícita de toString cuando quería información de depuración sobre un objeto, porque en caso de que el objeto sea nulo, no arroja una Excepción.

Por ejemplo:

System.out.println("obj: "+obj);

en lugar de:

System.out.println("obj: "+obj.toString());

¿Hay alguna diferencia aparte del caso nulo?
¿Puede funcionar el último caso, cuando el primero no?

Editar:
¿Qué se hace exactamente, en caso de una llamada implícita?

Answer 1

Hay poca diferencia. Use el que sea más corto y funcione con más frecuencia.

Si realmente desea obtener el valor de cadena de un objeto por otros motivos, y desea que sea nulo, haga lo siguiente:

String s = String.valueOf(obj);

Editar : la pregunta se amplió, por lo que extenderé mi respuesta.

En ambos casos, compilan algo como lo siguiente:

System.out.println(new StringBuilder().append("obj: ").append(obj).toString());

Cuando su toString () está implícito, lo verá en el segundo anexo.

Si observa el código fuente de Java, verá que StringBuilder.append (Object) tiene este aspecto:

public StringBuilder append(Object obj) {
    return append(String.valueOf(obj));
}

donde String.valueOf tiene este aspecto:

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

Ahora, si toString () usted mismo, omite un cheque nulo y un marco de pila y va directamente a esto en StringBuilder :

public StringBuilder append(String str) {
    super.append(str);
    return this;
}

Entonces ... cosas muy similares suceden en ambos casos. Uno solo hace un poco más de trabajo.

Answer 2

Como han dicho otros, utilice el " " + obj método.

De acuerdo con Java Language Spec :

• Si el término es nulo, use "null"
• Los tipos primitivos se convierten utilizando el constructor de tipo caja new Boolean (X) o lo que sea
Se invoca
• toString () (o equivalente)
• si el resultado de toString () es nulo , use "null"
• Concatenar las cadenas.

Answer 3

No hay diferencia excepto, como usted dice, la seguridad nula. Siempre prefiera lo primero a lo último.

Answer 4

En realidad, si su invariante dice que el objeto nunca debería ser nulo, no importa. Por lo tanto, depende de si acepta o no que obj sea nulo.

Answer 5

Es bastante fácil escribir un tipo de referencia genérico.

class ref
{
  static public class Reference<T>
  {
    private T value;
    public Reference(T value) { set(value); }
    public Reference() { set(null); }
    public void set (T value) { this.value = value; }
    public T get () { return this.value; }
    public String toString() { return String.valueOf(this.value); }
  }

  static void fillString (Reference<String> str)
  {
    str.set("foo");
  }

  public static void main (String[] args)
  {
    Reference<String> str = new Reference<String>("");
    fillString(str);
    System.out.println (str);
  }
}

Ejecutarlo proporciona el resultado requerido:

javac ref.java && java ref
foo