Change default return of an object in Java

Question

The default return of an object in Java is to return the toString method, is there a way to change this behavior to for example return a number or some other type or is this just a core unchangeable component of the language?

Test test = new Test();
blankMethod(test);

I am not sure why people are saying my assumption is wrong... if I Override the toString method of object it will output that new toString method...

@Override
public String toString() {
    System.out.println("This method is run when the object is used as a parameter");
    return "test";
}

Answer 1

The default return of an object in Java is to return the toString method

That's how PrintStream.println works. Any object in java extends java.lang.Object and therefore inherits Object behavior. In particular, any method which takes Object as an argument, also can take any object of another type. However, you can override any public or protected method defined in Object. In your case you should override toString() method in Test class, otherwise if you pass Test object to PrintWriter.println(), it'll use toString from superclass (Object in your case). So, if i understood your question correctly, the answer is no.

Update: your terminology is wrong. There is no default return of an object in java. Returning Object.toString is the default behavior only for PrintStream.println(Object).

Update2: more widely, Java doesn't support implicit type conversion except upcasting. In your case, Test extends Object, but it doesn't extend String (actually, String is final and therefore you can't extend it). So, if you try to pass Test object to method which only takes String, you'll get compilation error because String and Test belong to different branches of class hierarchy.

Answer 2

You are actually calling

PrintStream.println(Object x)

instead of

public void println(String x)

The PrintStream.println(Object x) implementation is below:

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

The method calls String.valueOf(x) whose implementation is below:

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

Note that the Object.toString() method is being called.

Notes on implicit conversion

An Object is only implicitly converted to a String using the toString method when the string concatenation operator (+) is invoked. More exactly the conversion works as follows:

A value x of primitive type T is first converted to a reference value...

This reference value is then converted to type String by string conversion. Now only reference values need to be considered.

If the reference is null, it is converted to the string "null" (four ASCII characters n, u, l, l). Otherwise, the conversion is performed as if by an invocation of the toString method of the referenced object with no arguments; but if the result of invoking the toString method is null, then the string "null" is used instead.

The toString method is defined by the primordial class Object"

Java Language Specification 15.18.1

One language (of many) that expand on the idea of implicit conversions is Scala which allows one to bring a conversion (e.g., A -> B) into scope which is then invoked whenever some type (A) is passed as an argument when a different type (B) is required.

Answer 3

This answers "why people are saying my assumption is wrong".

Here is a simple program:

public class Test {
  public String toString(){
    return "I am a Test object.";
  }

  public int add(int a, int b){
    return a+b;
  }
  public static void main(String[] args) {
    Test object = new Test();
    System.out.println(object);
    System.out.println(object.add(2,2));
    System.out.println(adder(object));
  }

  public static int adder(Test test){
    return test.add(3,5);
  }
}

Output:

I am a Test object.
4
8

The System.out.println method has to turn its argument into a String, one way or another. If it is passed an object reference, it uses its toString() method. If it is passed a primitive, such as an int expression, it converts it in an appropriate way.

It is nothing to do with what is being returned.

It also has nothing to do with any automatic conversion on passing a reference as an argument. See the third line of output, which depends on using the Test reference I passed to adder as a Test, not a String.

If you want to change what println prints, do what I did above, and pass it something different.