Compiler issue, or following specification

Question

Hi there
Here's a quick one for you compiler and java spec gurus out there. I'm going to show two versions of a class with a potentially ambiguous method call:
public class TheClassWithAmbiguity  {
  private void theMethod(String string) {
    System.out.println("Performing the String method");
  private void theMethod(Integer integer) {
    System.out.println("Performing the Integer method");
  public static void main(String[] args) {
    new TheClassWithAmbiguity().theMethod(null);
public class TheClassWithoutAmbiguity  {
  private void theMethod(String string) {
    System.out.println("Performing the String method");
  private void theMethod(Object object) {
    System.out.println("Performing the Object method");
  public static void main(String[] args) {
    new TheClassWithoutAmbiguity().theMethod(null);
}Can anyone explain why TheClassWithoutAmbiguity quite happily compiles and calls theMethod(String string) and TheClassWithAmbiguity does not compile complaining about ambiguity. It would appear that, on issues of ambiguity, Object is a special case and is treated differently by the compiler. In fact, the compiled code for TheClassWithoutAmbiguity shows an explicit cast to a String for the null value.
Thanks in advance,
Adam

Answer 1

Because the compiler cannot determine which method should actually be called in your ambiguous class it has to throw an error.
In your unambigious call, the call with a value of null will be sent to the method with the narrowest of signatures in this case the method with a String signature.
Remember the value here is a compile time value so the type cannot be determined by the compiler therefore it a rule that says the call should be routed to the method signature with the narrowest of signatures where possible. If it is not possible to narrow the method down in this fashion then it attempts to find a method that satisfies the general case (see my example below).
Interestingly, this code shows some more of the behaviour. Without looking at the Language Spec (too late for this) the exact wording escapes me.
public class QuickAndDirty {
    public static final Object anObject = null;
    public static final String aString = null;
    public static final Integer anInteger = null;
    /** Creates a new instance of QuickAndDirty */
    public QuickAndDirty() {
    public void someMethod(Object o) {
        System.out.println("Object signature");
    public void someMethod(String s) {
        System.out.println("String signature");
     * @param args the command line arguments
    public static void main(String[] args) {
        QuickAndDirty qad = new QuickAndDirty();
        qad.someMethod(null);
        qad.someMethod(aString);
        qad.someMethod(anObject);
        qad.someMethod(anInteger);
}