24 
class Test {
    public static void main() {
        String s1 = null + null; //shows compile time error
        String s1 = null;
        String s2 = s1 + null;   //runs fine
    }
}

Can anybody please explain the reason for this behavior?

Improve this question
5
  • 9
    A question which might lead you the way: What type would you assign the expression "null + null" and why? Commented Apr 9, 2014 at 17:08
  • 1
    The first might presumably work if "null" always only referred to the lack of a String object, but, in fact, it signals the absence of ANY object, and hence "+" has no object type to guide the choice of a specific meaning for "+". Commented Apr 9, 2014 at 17:13
  • 2
    Well null is explicit, so null + null is just one of those low hanging fruit checks during compile time, but variables can become null during run time. In the second case, the compiler would have to check that s1 is null all the way up to the assignment of s2 in order to kick it out. Commented Apr 9, 2014 at 17:13
  • @Mike - If the null were replaced with a String variable set to null then the compiler would attempt to invoke String ops to handle it. Would fail, though, because concat would be invoked with a null. Commented Apr 9, 2014 at 17:17
  • Also: this code is invalid because s1 is declared twice. Maybe use different scopes by putting the two examples in different blocks? Commented Apr 10, 2014 at 8:49

5 Answers 5

Reset to default
28

This code:

String s1 = null + null;

tries to perform addition operation on two null, which is not valid.

while here:

String s1 = null;
String s2 = s1 + null;

You assigned null to s1. Then you perform concatenation of s1 and null. The type of s1 is String, so null in s1 + null will be converted to "null" string as per the String conversion rules, as in JLS §15.1.11 - String Conversion:

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.

and concatenation will be done as - s1 + "null";

Improve this answer
Sign up to request clarification or add additional context in comments.

13 Comments

@BheshGurung, Associativity isn't really relevant in this situation since there is only one operator present, but consider the expression a + b + c. Because + is left-associative, the expression is parsed as (a + b) + c. If it were right-associative, the expression would be parsed as a + (b + c). (It's also possible for an operator to be non-associative, in which case the expression would either be a syntax error or have some kind of special meaning, depending on the syntax definitions.)
It won't be converted into the string "null", will it? I thought it would just stay as a null pointer.
I'm actually mildly surprised that this works. The JLS only says, "If only one operand expression is of type String, then string conversion (§5.1.11) is performed on the other operand to produce a string at run time." Nothing is mentioned about any case where string conversion is applied to both operands, which is necessary for this to work.
@Stendika: It gets converted for the s1 + null addition, not the s1 = null assignment.
@user2357112 And isn't s1 of type String, in s1 + null? There is no type for null, when used directly, but when it's assigned to String s1, the operator will see the type of s1, and not that whether it is null or not.
|
15

The + operator as String concatenation only applies if one (or both) of the operands has type String.

This is defined in the Java Language Specification

If the type of either operand of a + operator is String, then the operation is string concatenation.

In

String s1 = null + null; //shows compile time error

the operands have the null type, ie. not String, so no string concatenation happens. Java then thinks you are doing an addition which also doesn't work on null types.

In

String s2 = s1 + null;   //runs fine

s2 has type String even though it is referencing null, so string concatenation can happen.

Improve this answer

Comments

9

In below case, you are performing operation on two null and + operation is not defined for two null.

String s1 = null + null;

And in this one you are performing concatenation of String with null.

String s2 = s1 + null;

And another interesting case is,

String abcd = (String) null + null;

That will be resulted in "nullnull" string as you are casting String to null and again concatenation will be performed. so first null will be treated as String.

Improve this answer

Comments

3

From Javadoc:

The Java language provides special support for the string concatenation operator ( + ), and for conversion of other objects to strings. String concatenation is implemented through the StringBuilder(or StringBuffer) class and its append method

Thus, at least the left operand must not be null since StringBuffer.append(Object object) accept Object (including null) as parameter.

Improve this answer

5 Comments

+1 for referencing StringBuffer - I think that's an important omission in the accepted answer. Your answer is less complete overall, though.
Yes, less complete since the majority of the concept had already been explained.
I think you've failed to explain how StringBuffer accepting null answers the question, though - this answer should show what the compiler converts the string concatenation to, to make it clear why neither of the two nulls causes a problem. Also, I would suggest specifically mentioning the other answer that explains what you left out - otherwise this is just a competing answer that fails to answer the question. (Actually, maybe I should provide a competing answer myself.)
Actually... I just tested this, and StringBuilder won't accept append(null) - it complains that it's ambiguous. Not sure what to make of that.
Actually, you would have to cast to a specific type: like append((String)null) in order to be able to select the right overloaded method. On the "concept" aspect, it accepts null, technically, a cast is necessary.
2

Basically this because you are dealing with literals, and because of that, the COMPILER is trying to perform an operation on those literal values. It's happening at compile time, and there's nothing to do with two null values.

The compiler error you are getting is the equivalent of an exception -- the compiler doesn't know what to do with it, so it errors out and gives the types an explanation saying it doesn't work.

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.