Question

I have an interface Damageable as follows

public interface Damageable {
    public void handleCollision(float impulse);
}

a class which implements this interface, BaseObject

public class BaseObject implements Damageable

Now in a third class, I have an ArrayList of the type BaseObject

public class ObjectManager {    
    public ArrayList<BaseObject> bodies;

What I am trying to do is to pass the ArrayList bodies to a method of another class which accepts ArrayList

public CollisionManager( ArrayList<Damageable> _bodies) {
        bodies = _bodies;
}

Java does not let me do new CollisionManager(bodies) where bodies is of type ArrayList and BaseObject implements Damageable

I have tried casting. Says cannot cast from
ArrayList<BaseObject> to ArrayList
Also tried using Class<? extends Damageable> but then I’m unable to call methods declared in the interface Damageable. How can I pass the ArrayList?

Answer 1

You have to be explicit with your generics. Therefore, you have to inform the compiler that your generic type doesn’t have to be a Damagable per se, rather it can extend Damagable:

public CollisionManager(ArrayList<? extends Damagable> bodies) {

---

By the way, notice that I changed your variable to bodies rather than _bodies. Underscores are not part of the standard Java coding conventions.

---

^{Edit in response to the OP’s comments}

Let’s say that, instead of an interface, you had a concrete class called Damagable. Telling the compiler <? extends Damagable> says that it doesn’t have to be an instance of Damagable. It’s okay that the type extend Damagable. Otherwise, the compiler assumes that you have a Damagable exactly.

It doesn’t make as much sense when you think of Damagable as an interface, since there is not case where you would have an instance of Damagable. But they work in essentially the same way.

You have to remember that you’re working with Java types, not classes. Java’s type syntax and structure is less robust than it’s class structure. There is no concept of implements when it comes to types.

---

^{Last round of edits}

Finally, I should note that it’s generally better to use an interface for method/constructor parameters and method return types. This allows you and those that use your methods to use whatever implementation you please, and allows you to change your implementation as you please.

So with those revisions, you would have:

public CollisionManager(List<? extends Damagable> bodies) {