Cannot pass ArrayList to method taking ArrayList

Question

I have an interface and a class implementing it:

public interface IFoo{
    Integer bar();
}

public class Foo implements IFoo{
    @Override
    public Integer bar(){
        return 42;
    }
}

Now in another class, I have a function which takes an ArrayList of the interface type.

public class Something {
    public static void function(ArrayList<IFoo> foos){
        //do something on foos
    }
}

I want to use this function on an array list of Foo:

ArrayList<Foo> myFoos = new ArrayList<Foo>();
Something.function(myFoos);//can NOT do this

What is the problem or what shall I do?

Slightly off topic, but why not `public static void function(IFoo foos...)` ? — Leon, Sep 29 '14 at 05:42
I agree with @Leon. Coding to the *interface* is a good practice. — TheLostMind, Sep 29 '14 at 05:43
your interface name is IFoo and arraylist your are generating is for Foo. however inside Something class in function signature you have mentioned correctly. — Rajen Raiyarela, Sep 29 '14 at 05:43

John Kugelman · Accepted Answer · 2014-09-29T05:48:33.987

Generics to the rescue!

public static void function(ArrayList<? extends IFoo> foos){
    //do something on foos
}

Now the function takes any kind of array list where the contained type is either IFoo or is derived from it.

For what it's worth, it's also a good idea to use the most generic type possible. Do you really need an ArrayList, or would any kind of List do? Or maybe any kind of Collection?

public static void function(List<? extends IFoo> foos);
public static void function(Collection<? extends IFoo> foos);

A good rule of thumb is to be conservative in what you send and liberal in what you accept from others. Using more generic parameter types falls under the "be liberal" part.

Thanks. Collection type may depend. – Khan 'Sadh' Mostafa Sep 29 '14 at 05:51 — Khan 'Sadh' Mostafa, Sep 29 '14 at 05:51

score 1 · Answer 2 · edited May 23 '17 at 10:33

1

I would probably leave the method signature unchanged (except to accept an List<IFoo>) and promote the usage of the interface type, such as:

List<IFoo> myFoos = new ArrayList<IFoo>();

If needing to use List<Foo> - again, away with the ArrayList! - then I would likely still keep the simpler signature and force the caller to cast as appropriate, or otherwise provide a List<IFoo> expression, leaving the responsibility of such an operation at the call-site.

(I'm largely biased against subtyping, and prefer to sidestep this covariance issue entirely when practical.)

edited May 23 '17 at 10:33

Community

1
1

answered Sep 29 '14 at 05:50

user2864740

60,010
15
145
220

Okay, I'll bite. Why are you biased against subtyping? – John Kugelman Sep 29 '14 at 06:01
@JohnKugelman Not so much subtyping as inheritance subtype-relationsips: mainly the increased (and too-easy) dependence upon LSP (beyond a defined interface contract) and concrete types. – user2864740 Sep 29 '14 at 06:12
Ah, gotcha. I'm in agreement with you there. I thought you had something against wildcard qualifiers specifically. That'd be an oddly specific thing to hate. ;-) – John Kugelman Sep 29 '14 at 06:15
@JohnKugelman Oh no, not at all - but if I can do away without such then I'll try and do so first. (This question isn't a really good example of when they really shine.) – user2864740 Sep 29 '14 at 06:15

score 0 · Answer 3 · answered Sep 29 '14 at 05:42

0

you can do it by using generics :

public static void function(ArrayList<? extends IFoo> foos){

}

So your problem is easily get solved.

answered Sep 29 '14 at 05:42

user3145373 ツ

7,858
6
43
62

Cannot pass ArrayList to method taking ArrayList

3 Answers3