How an object will call toString method implicitly?

Question

如果我正在打印该类的对象，那么即使我没有编写toString()方法，它也在打印toString()方法的实现，那么实现是什么，它如何在内部调用toString() ？

Answer 1

You're not explicitly calling toString() , but implicitly you are:

See:

System.out.println(foo); // foo is a non primitive variable

System is a class, with a static field out , of type PrintStream . So you're calling the println(Object) method of a PrintStream .

It is implemented like this:

   public void println(Object x) {
       String s = String.valueOf(x);
       synchronized (this) {
           print(s);
           newLine();
       }
   }

As we see, it's calling the String.valueOf(Object) method.
This is implemented as follows:

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

And here you see, that toString() is called.

Answer 2

Every object in Java IS-A (n) Object as well. Hence, if a toString() implementation has not been provided by a class the default Object.toString() gets invoked automatically.

Object.toString() 's default implementation simply prints the object's class name followed by the object's hash code which isn't very helpful. So, one should usually override toString() to provide a more meaningful String representation of an object's runtime state.

even I am not writing the toString() method so what are the implementation,how it is calling toString() internally?

toString() is one of the few methods (like equals() , hashCode() etc.) that gets called implicitly under certain programmatic situations like (just naming a few)

• printing an object using println()
• printing a Collection of objects ( toString() is invoked on all the elements)
• concatenation with a String (like strObj = "My obj as string is " + myObj; )

Answer 3

一切都继承自Object，因此如果尚未定义，则将调用Object上的toString 。

Answer 4

toString() method is present in Object class, so when u put obj in System.out.println(obj);, impliciyly it will call toString() present in Object class since every user created class will implicitly inherits Object class so as ur newly created class, that means that toString() is available in ur class so it will print something like for example: "PkgNamePackage.Classname@12cf4" However if u explicitely override toString method and give ur own implementation then it will written the string what ever u give in Overriden tostring method(); ex:

public class DogArray {
    @Override
    public String toString() {
        return "Im the newly created Object";
    }

    public static void main(String args[]) {
        DogArray d1 = new DogArray();
        System.out.println(d1);
    }
}

output: Im the newly created Object

Answer 5

在java中，对象类是每个类的超类。每当您将参数传递给system.out.println时，内部对象类将转换为字符串方法。它返回给定的类名@引用值，但根据我们的应用需求对象类到字符串方法将在集合和字符串类中重写。它返回其内容。