current community

your communities

more stack exchange communities

Stack Exchange
tour help
careers 2.0
Take the 2-minute tour ×
Stack Overflow is a question and answer site for professional and enthusiast programmers. It's 100% free, no registration required.
up vote 18 down vote favorite
2
 
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?

share|improve this question
7  
A question which might lead you the way: What type would you assign the expression "null + null" and why? –  Micha Wiedenmann 19 hours ago
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 "+". –  Hot Licks 19 hours ago
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. –  Mike 19 hours ago
    
@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. –  Hot Licks 19 hours ago
    
Also: this code is invalid because s1 is declared twice. Maybe use different scopes by putting the two examples in different blocks? –  Arlaud Pierre 4 hours ago
add comment

5 Answers

up vote 20 down vote accepted

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 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.

share|improve this answer
    
@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.) –  Brian S 18 hours ago
3  
It won't be converted into the string "null", will it? I thought it would just stay as a null pointer. –  Stendika 16 hours ago
    
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. –  user2357112 13 hours ago
1  
@Stendika: It gets converted for the s1 + null addition, not the s1 = null assignment. –  user2357112 13 hours ago
    
@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. –  Rohit Jain 8 hours ago
show 4 more comments
up vote 14 down vote

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.

share|improve this answer
add comment
up vote 8 down vote

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.

share|improve this answer
add comment
up vote 3 down vote

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.

share|improve this answer
    
+1 for referencing StringBuffer - I think that's an important omission in the accepted answer. Your answer is less complete overall, though. –  Brilliand 16 hours ago
    
Yes, less complete since the majority of the concept had already been explained. –  Mik378 16 hours ago
    
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.) –  Brilliand 16 hours ago
    
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. –  Brilliand 15 hours ago
    
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. –  Mik378 15 hours ago
add comment
up vote 2 down vote

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.

share|improve this answer
add comment

Your Answer

 
discard

By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.