| << Chapter < Page | Chapter >> Page > |
If your answer was A. Compiler Error , you were correct.
The compiler error was caused by the code shown in Listing 2 .
| Listing 2 . The code with the problem. |
|---|
public static void fillIt(Collection ref){
ref.add(0,new MyClass(4)); |
The problem here is that the method named fillIt receives a reference to an object of the ArrayList class as the interface type Collection , and attempts to call the following overloaded method on that reference:
add(int index, Object element)
However, the Collection interface knows nothing about a method having that signature.
The ArrayList class implements both the Collection interface and the List interface. As you may recall from earlier modules in this series, List is a sub-interface of Collection . The List interface declares the following overloaded versions of the add method:
The second of these two methods, which is called in Listing 2 , is unknown to the Collection interface. The Collection interface declares only the first version of the add method shown above.
This is the result of specialization. A List object is a more-specialized collection than a Collection object.
Therefore, the version of the add method that requires two parameter cannot be called on a reference to an ArrayList object when that object is treated as the generic type Collection .
Now, take a look at the modified version of the program as shown in Listing 3 .
What output is produced by the program shown in Listing 3 ?
| Listing 3 . The program named Comparable02. |
|---|
//File Comparable02.java
import java.util.*;public class Comparable02{
public static void main(String args[]){
new Worker().doIt();}//end main()
}//end class Comparable02class Worker{
public void doIt(){Iterator iter;
Collection ref;ref = new ArrayList();
Populator.fillIt(ref);iter = ref.iterator();
while(iter.hasNext()){System.out.print(iter.next());
}//end while loopSystem.out.println();
}//end doIt()}// end class Workerclass Populator{
public static void fillIt(Collection ref){((List)ref).add(0,new MyClass(4));
((List)ref).add(1,new MyClass(4));((List)ref).add(2,new MyClass(3));
((List)ref).add(3,new MyClass(2));((List)ref).add(4,new MyClass(1));
((List)ref).add(3,new MyClass(5));}//end fillIt()
}//end class populatorclass MyClass{
int data;MyClass(){
data = 0;}//end noarg constructor
MyClass(int data){this.data = data;
}//end parameterized constructorpublic String toString(){
return "" + data;}//end overridden toString()
}//end MyClass |
If your answer was G. 443521 , you are correct.
This version of the program illustrates a mechanism for correcting the problem in the earlier program shown in Listing 1 . The updated code that corrected the problem is shown in Listing 4 .
| Listing 4 . The corrected code. |
|---|
class Populator{
public static void fillIt(Collection ref){((List)ref).add(0,new MyClass(4));
((List)ref).add(1,new MyClass(4));((List)ref).add(2,new MyClass(3));
((List)ref).add(3,new MyClass(2));((List)ref).add(4,new MyClass(1));
((List)ref).add(3,new MyClass(5));}//end fillIt()
}//end class populator |
Notification Switch
Would you like to follow the 'Object-oriented programming (oop) with java' conversation and receive update notifications?
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|