Chapter 3 ■ Java Class Design

public static void main(String[]s) { System.out.println(new Circle()); System.out.println(new Circle(50, 100)); System.out.println(new Circle(25, 50, 5));

}

}

This program prints

center = (20,20) and radius = 10 center = (50,100) and radius = 10 center = (25,50) and radius = 5

As you can see, the compiler has resolved the constructor calls depending on the number of arguments. Did you notice that you are duplicating the code inside the three constructors? To avoid that code duplication—and reduce your typing effort—you can invoke one constructor from another constructor. Of the three constructors, the constructor taking x-position, y-position, and radius is the most general constructor. The other two constructors can be rewritten in terms of calling the three argument constructors, like so:

public Circle(int x, int y, int r) { xPos = x;

yPos = y; radius = r;

}

public Circle(int x, int y) {

this(x, y, 10); // passing default radius 10

}

public Circle() { this(20, 20, 10);

// assume some default values for xPos, yPos and radius

}

The output is exactly the same as for the previous program, but this program is shorter; you used the this keyword to call one constructor from another constructor of the same class.

Overload resolution

When you define overloaded methods, how does the compiler know which method to call? Can you guess the output of the code in Listing 3-9?

60

Chapter 3 ■ Java Class Design

public static void main(String[] args) { byte b = 9;

aMethod(b);

aMethod(9); Integer i = 9; aMethod(i); aMethod("9");

}

}

It prints

short int object String

Here is how the compiler resolved these calls:

•In the first method call, the statement is aMethod(b) where the variable b is of type byte. There is no aMethod definition that takes byte as an argument. The closest type (in size) is short type and not int, so the compiler resolves the call aMethod(b) to aMethod(short val) definition.

•In the second method call, the statement is aMethod(9). The constant value 9 is of type int. The closest match is aMethod(int), so the compiler resolves the call aMethod(9) to aMethod(int val) definition.

•The third method call is aMethod(i), where the variable i is of type Integer. There is no aMethod definition that takes Integer as an argument. The closest match is aMethod(Object val), so it is called. Why not aMethod(int val)? For finding the closest match, the compiler allows implicit upcasts, not downcasts, so aMethod(int val) is not considered.

•The last method call is aMethod("9"). The argument is a String type. Since there is an exact match, aMethod(String val) is called.

This process of the compiler trying to resolve the method call from given overloaded method definitions is called overload resolution. For resolving a method call, it first looks for the exact match—the method definition with exactly same number of parameters and types of parameters. If it can’t find an exact match, it looks for the closest match by using upcasts. If the compiler can’t find any match, then you’ll get a compiler error, as in Listing 3-10.

Listing 3-10.  More Overloaded.java

class Overloaded {

public static void aMethod (byte val ) { System.out.println ("byte"); } public static void aMethod (short val ) { System.out.println ("short"); }

public static void main(String[] args) { aMethod(9);

}

}

61

Chapter 3 ■ Java Class Design

Here is the compiler error:

Overloaded.java:6: cannot find symbol symbol : method aMethod(int) location: class Overloaded

aMethod(9);

^

1 error

The type of constant 9 is int, so there is no matching definition for aMethod for the call aMethod(9). As you saw earlier with respect to the overload resolution, the compiler can do upcasts (e.g., byte to int) for the closest match, but it does not consider downcasts (e.g., int to byte or int to short, as in this case). Hence, the compiler does not find any matches and throws you an error.

What if the compiler finds two matches? It will also become an error! Listing 3-11 shows an example.

Listing 3-11.  Two Matches in Overloaded.java

class Overloaded {

public static void aMethod (long val1, int val2) { System.out.println ("long, int");

}

public static void aMethod (int val1, long val2) { System.out.println ("int, long");

}

public static void main(String[] args) { aMethod(9, 10);

}

}

Here is the compiler error:

Overloaded.java:6: reference to aMethod is ambiguous, both method aMethod(long,java.lang.Integer) in Overloaded and method aMethod(java.lang.Integer,long) in Overloaded match

aMethod(9, 10);

^

1 error

Why did this call become an “ambiguous” call? The constants 9 and 10 are ints. There are two aMethod definitions: one is aMethod(long, int) and another is aMethod(int, long). So there is no exact match for the call aMethod(int, int). An integer can be implicitly upcasted to both long as well as Integer. Which one will the compiler choose? Since there are two matches, the compiler complains with an error that the call is ambiguous.

Overload resolution fails (with a compiler error) if there are no matches or ambiguous matches.

62