The type of the null literal is "null". JLS3, 3.10.7.

gokul.b@gmail.com wrote On 10/10/05 16:47,:

   Java does not "ignore" the (Object) constructor.  Java
has a whole lot of rules to determine how overloaded methods
and constructors are resolved.  They're spelled out in great
detail in the Java Language Specification, but the informal
notion is that Java uses the "most specific" overloading that
it can.  Consider these three methods with the same name:

    void method(Object o)  { System.out.println(1); }
    void method(Number n)  { System.out.println(2); }
    void method(Integer i) { System.out.println(3); }

   When you write `method(new HashMap())' which method is
called?  Well, a HashMap is not an Integer and not a Number,
but it is an Object and so method #1 is called; it's the
only possible candidate.

   Things get more interesting when more than one candidate
might be applicable, as in `method(new Integer(42))'.  All
three methods could conceivably apply, since an Integer is
an Integer (duh...), but is also a Number and also an Object.
Java resolves this in favor of method #3, because Integer is
the "most specific" description for an Integer reference.

   Finally, consider `method(new Double(42.0))'.  A Double
is not an Integer so method #3 isn't called, but a Double is
a Number and is an Object.  Number is "more specific" than
Object, so method #2 is called.

   Now to your case.  You wrote `method(null)' (in essence)
and since `null' itself carries no type information it's not
immediately clear what should happen.  Java considers Object,
Number, and Integer, and finds that all three of them could
match `null'.  However, Integer is still the "most specific,"
so method #3 is used.  You could get different results (which
ones?) by writing `method((Long)null)' or `method((URL)null)'.

   But then you changed things by adding yet another method:

    void method(String s)  { System.out.println(4); }

This muddies the waters.  The calls with HashMap, Integer,
and Double and with `null' cast to a type work just as before,
but what about the call with plain `null' as an argument?  All
four methods might apply, but now Java can't decide what to
do because String and Integer are "equally specific."  javac
throws up its hands and tells you to stop speaking in riddles.

   Things get more complex when there are multiple arguments,
when you've got classes that implement several interfaces, and
so on.  The exact rules are in the JLS, but mostly they just
try to formalize this notion of "more specific."

It's more than a hint.  "(Object) null" is a typecast expression whose
/type/ is Object and whose /value/ is null.  The compiler uses the type
of the expression to select the appropriate method.

No, it isn't.  See other posts in this thread, or read JLS3 section 4.1.

Naturally; See JLS3 section 15.12.  Be warned: this is a lengthy and
complicated section of the spec.  For the less intrepid, Eric Sosman
gave a good run-down of how all that applies to this particular case.

It seems to me that (Integer)null might either be a compile time error
or invalid cast exception at run time.  From the discussions, I gather
neither happens.  

I guess what Eric's findings mean is :

 Integer n = null;
 someMethod ( n );

has the same effect as

 someMethod ( (Integer) null );

This is a reply, to a reply by John C. Bollinger, about the message below.
Something's gone a bit wrong here, and I've lost the reply itself - sorry!

Well, granted, but I'm more of a nuts and bolts man so I try to keep out  
of the JLS as much as possible (it hurts my head ;)). Thanks for boiling  
down what it says :) What I was getting at, though, was that in real terms  
inside the JVM itself, null has no _runtime type_ of it's own, and can be  
cast to to any other type.

I see so much grossly incorrect and misleading information pass through  
this newsgroup, that it's good to see the heavyweights still jumping on  
the only-slightly-relevant detail from the occasional poster.

When I said "I imagine it is", I meant say "It is, but I cannot be  
bothered to find the reference. Go look if you're interested". Thanks for  
covering my laziness ;)