Java string literal automatically interpreted as String object, but how?

Question

What are the mechanics behind Java automatically interpreting string literals as String objects, since there are no overloaded operators and there is no default support for

Answer 1

Basically the compiler rewrites your code.

String x = "Some String";

For concatenation, it is just syntactic sugar for StringBuffer append method, ie this:

z += " with some more in it";

is compiled as:

z = new StringBuffer(z).append(" with some more in it").toString();

Now for a single concat this is an object created and 2 method calls, so if you are building a very long string inside a loop, it is FAR more efficient to write:

StringBuilder buf = new StringBuilder(); // Not synchronized so quicker than StringBuffer
while ( condition is true )
    buf.append(...);
String z = buf.toString();

rather than:

String z = "";
while (condition is true)
   z += "...";

Edit: removed wrong code example...

Answer 2

It's a little of both.

The JVM has byte codes for loading string literals onto the runtime stack, and these opcodes are specified in the JVM spec to work by pushing an appropriately-constructed String object onto the stack whose contents are equal to some string literal specified in the class file. There is no specification for how this is done other than that the String object must be interned, meaning that the transformation is implementation-specific.

At the language level, the compiler can treat any String literal it sees as a complete String object for the purposes of type checking, and can then just write out the literal and the appropriate bytecodes into the class file.

Answer 3

Java actually does have a few overloaded operators. For example, + can be applied to String objects as well as to int, float, and other numerical types. In each case, the return type is defined by the type of the expression on each side of the +. However, all overloaded operators are predefined in the language; programmers have no mechanism in the language to define any others. See the language specification for details.