How toString() is automatically call inside println()

Question

I just started learning Java. What I've learned about constructor is that :

1. It will automatically run when an object is initialized.

2. The name of the constructor has be the same as the class name.

Now, below is where I'm starting to get confused.

class Frog{

   public String toString() {
      return "Hello";
   }
}

public class App {

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

My question : Since public String toString () is not a constructor, then why can it behave like constructor when I run the program. I thought It can only be run when I call it from the App class.

Answer 1

Short answer: public frog1.toString() method call is used inside System.out.println(Object x) call stack.

But how? Let's find it out together :)

Take a look at the PrintStream class (which instance is used as System.out field value by default) source code and its println implementation that accepts Object argument:

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

And the String's valueOf method for argument with Object type is:

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

obj is frog1 in your case, its toString() method is called and returns "Hello" String instance for the console output)

Answer 2

The "toString" is not behaving like a constructor; the reason why it is being called is the second line in your main method:

  System.out.println(frog1);

This invokes toString on frog1.

Answer 3

When you call PrintStream class print(obj) / println(obj) method then internally it called write method with arguement as String.valueOf(obj) shown below :

public void print(Object obj) {
    write(String.valueOf(obj));
} 

Now String.valueOf(obj) does the task of calling to String method as shown below :

 /** 
 * Returns the string representation of the <code>Object</code> argument. 
 * 
 * @param   obj   an <code>Object</code>. 
 * @return  if the argument is <code>null</code>, then a string equal to 
 *          <code>"null"</code>; otherwise, the value of 
 *          <code>obj.toString()</code> is returned. 
 * @see     java.lang.Object#toString() 
 */ 
public static String valueOf(Object obj) {
return (obj == null) ? "null" : obj.toString();
} 

Answer 4

public String toString(){..} is method of class Object , here overridden specifically for Frog class. This method returns object value representation. It's a method not a constructor. Please remember constructor cannot return value.

Valid constructor would be something like below:

 public Frog(){}

Answer 5

The toString method overrides Object.toString

public String toString() {
      return "Hello";
}

So when call

 System.out.println(frog1);

It toString's the object to "hello"

Answer 6

The usage of toString is to give some meaningful representation for your class. Something like description about the object or class can go inside toString method.

Whenever the object is used with any String referenced operations like System.out.print or String s="abcd"+frog1;" the content of toString will be returned.

If toString is not overridden it would return the object class and its hash code. Please check here

From your code,

• Frog frog1 = new Frog(); => creates object frog1 of type Frog.
• System.out.println(frog1); => outputs the String representation
  of the object frog1.

Hope it explains.

Answer 7

I'm not sure you understand what "behaving like a constructor" means. The Frog constructor (the default one, because you haven't written one) is called when you do new Frog(). The call to .toString() is done automatically inside the call to .println(), which is in the line after the call to the constructor.

You may be getting confused because toString() is the only method you have declared. However, you are missing the knowledge that there is an implicit default constructor automatically in your class. If you were to type it out it would look like this:

public Frog() {
    // default constructor does nothing
}

It is that default constructor that is "behaving like a constructor". toString() is just behaving like a method that is being called by another method (the key thing being that println(Object o) is definitely certain that Object has a toString() method because it is part of the class definition).