answer to this question

[Mike Rudiger]

Can someone tell me what this answer is? I think its C but thats not what the answer is.

Given a method declared as:
public static <E extends Number> List<? super E> process(List<E> nums)
A programmer wants to use this method like this:
// INSERT DECLARATIONS HERE
output = process(input);
Which pairs of declarations could be placed at // INSERT DECLARATIONS HERE to allow
the code to compile? (Choose all that apply.)
A. ArrayList<Integer> input = null;
ArrayList<Integer> output = null;
B. ArrayList<Integer> input = null;
List<Integer> output = null;
C. ArrayList<Integer> input = null;
List<Number> output = null;
D. List<Number> input = null;
ArrayList<Integer> output = null;
E. List<Number> input = null;
List<Number> output = null;
F. List<Integer> input = null;
List<Integer> output = null;
G. None of the above.

[Jesper de Jong]

"Joe Usenet", welcome to JavaRanch.

First, please check your private messages. You can see them by clicking My Private Messages.

If you copy a question from a book or mock exam then please quote your sources.

[Satya Maheshwari]

Hi Mike

Just curious to know what is the answer. Is it "G. None of the above."? Also what makes you think that C should be the answer? Also could you please quote your source?

[Mike Rudiger]

the answer is b, e, and f and it also says this:

"The return type of process is definitely declared as a List, not an ArrayList, so A and D
are wrong. C is wrong because the return type evaluates to List<Integer>, and that can't
be assigned to a variable of type List<Number>. Of course all these would probably cause a
NullPointerException since the variables are still null�but the question only asked us
to get the code to compile."

It is from the Cathy Sierra

[Satya Maheshwari]

I think the answer for this should be "None of the above" unless something is seriously wrong with my logic. The compiler(1.5.11) agrees with the discussion below:

public static <E extends Number> List<? super E> process(List<E> nums)
{...}
 
...//declare input and output
 
output = process(input);

Method Argument is of type List<E> where <E extends Number>. Hence the method argument can be a List of objects which extend number. For e.g. List<Float>, List<Double>, List<Integer> are all valid.

Method Return Type is List<? super E> where <E extends Number>. Hence the method return type is a list of objects which are superclass of an object which itself extends number. Hence return type is undefined due to ambiguity(it may be Number or some superclass of Number or Object etc. etc.)

Now moving to the options:

A. ArrayList<Integer> input = null;
ArrayList<Integer> output = null;
This is obviously wrong as return type of process is List which can never be assigned to an ArrayList without casting.

B. ArrayList<Integer> input = null;
List<Integer> output = null;
This is wrong as the return type is ambiguous(See discussion above on Method Return Type). As it is ambiguous, it cannot be List<Integer>

C. ArrayList<Integer> input = null;
List<Number> output = null;
This is wrong as the return type is ambiguous(See discussion above on Method Return Type). As it is ambiguous, it cannot be List<Number>

D. List<Number> input = null;
ArrayList<Integer> output = null;
This is obviously wrong as return type of process is List which can never be assigned to an ArrayList without casting.

E. List<Number> input = null;
List<Number> output = null;
This is wrong as the return type is ambiguous(See discussion above on Method Return Type). As it is ambiguous, it cannot be List<Number>. Also the method argument is also wrong as it can be a List of objects which extend number but here it is List<Number>.

F. List<Integer> input = null;
List<Integer> output = null;
This is wrong as the return type is ambiguous(See discussion above on Method Return Type). As it is ambiguous, it cannot be List<Integer>

G. None of the above.
Correct!!

Please comment if this resoning is correct/incorrect.

Regards

[Vishwanath Krishnamurthi]

Hi Satya,

Am pasting this from the K&B errata:

620....bug.......Q-16: method declaration s/b:
& 634
public static <E extends Number> List<E> process(List<E> nums)

[Siri Naray]

Still I dont understand the output. return type List<E> so we can return only a List and E could be an Integer. But how can answer B be right. the method argument is a List and in option B we are sending ArrayList. Can we send subtype of a Collection as an argument??

I have exam tomorrow morning and I am banging my head with Generics.

[Satya Maheshwari]

the method argument is a List and in option B we are sending ArrayList. Can we send subtype of a Collection as an argument??

Yes of course, an ArrayList is always a List.

[Kumar Biplav]

Hi,
I have a question  regarding the explanation  of  first option(A) which says ,"The return type of process is definitely declared as a List, not an ArrayList" but we can return an ArrayList to a method which has its return type declared as List,right?

[Tyoma Sakurakoji]

Kumar Biplav wrote:Hi,
I have a question  regarding the explanation  of  first option(A) which says ,"The return type of process is definitely declared as a List, not an ArrayList" but we can return an ArrayList to a method which has its return type declared as List,right?

You can return object of subclass from the method, but according to the method signature it will be "downgraded" to super class due to polymorphism nature. So, a returned ArrayList would be returned as List. To make it back to an ArrayList you'll need to perform an explicit cast. That's why an option A is not correct as well as other options having not List as an output.

[Campbell Ritchie]

Your explanation is correct (), but not quite.

Tyoma Sakurakoji wrote:. . . according to the method signature

The return type isn't part of the method signature.

it will be "downgraded" to super class due to polymorphism nature.

Say supertype, not superclass; java.util.List isn't a class. That is an example of inheritance, not of polymorphism.

So, a returned ArrayList would be returned as List. To make it back to an ArrayList you'll need to perform an explicit cast. That's why an option A is not correct . . . .

That is the right explanation. In real life, you would declare your ArrayList as List:-

public List<String> processIntoList(...);
{
   ...
}
// ...
List<String> words = processIntoList(...);
// ...
words = new ArrayList<>();
words.add("Tyoma");
words.add("Sakurakoji");

\you can change line 6 to read words = new LinkedList<>(); and nothing strange will happen.