CODEWITHSUNDEEP
javainterfacearraylist
wirate
wirate

Reputation: 695

Java - passing ArrayList of interface type

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?

Upvotes: 20

Views: 27720

Answers (3)

Tim Pote
Tim Pote

Reputation: 28029

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) {

Upvotes: 44

mikera
mikera

Reputation: 106351

Others will no doubt point out the technical solutions from the Java syntax perspective.

I'm just going to mention a few design issues that you should perhaps consider:

  • Your BaseObject implements Damageable. That means all BaseObjects are Damageable. Why not then just make a CollisionManager(ArrayList<BaseObject>)? Unless you are going to use Damageable elsewhere (i.e. there are things which are Damageable but are not BaseObjects) then it seems like an unnecessary abstraction.
  • Usually for collision detection in a game / simulation you would want to use a spatial data structure for collision detection (e.g. Octree, Quadtree or AABB tree) rather than an ArrayList. Searching for collisions in an ArrayList is an O(n^2) algorithm. This will become a big issue if you have a lot of live objects.
  • Damageable seems like a bad name, since the functionality relates to collision detection rather than damage - wouldn't Collidable be better?

Upvotes: 2

dann.dev
dann.dev

Reputation: 2494

Try ArrayList<? extends Damageable > _bodies.

This says that you want an ArrayList consisting of a Class that extends (well implements) Damageable

Upvotes: 2

Related Questions