java - manejo - Llamada explícita vs implícita de toString

string tostring java

Question

Solía ​​usar la llamada implícita de toString cuando quería información de depuración sobre un objeto, porque en el 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 el último caso funcionar cuando el primero no funciona?

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

Answer 1

En realidad, si su invariante dice que el objeto nunca debe ser nulo, no importa. Entonces depende de si acepta o no que obj sea nulo.

Answer 2

Hay poca diferencia. Usa el que es más corto y funciona más a menudo.

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

String s = String.valueOf(obj);

Editar : la pregunta se extendió, por lo que ampliaré mi respuesta.

En ambos casos, recopilan algo como lo siguiente:

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

Cuando su toString() está implícito, verá que en el segundo apéndice.

Si miras el código fuente a java, verás que StringBuilder.append(Object) ve así:

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

donde String.valueOf ve así:

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

Ahora, si toString() usted mismo, omite una verificación nula y un marco de pila e ir 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 3

No hay diferencia excepto, como dices, la seguridad nula. Siempre prefiero lo primero a lo último.

Answer 4

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);
  }
}

Al ejecutarlo se obtiene el resultado requerido:

javac ref.java && java ref
foo

Answer 5

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

De acuerdo con The Java Language Spec :

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