How to convert list of objects to list of interfaces?

Question

I have some class that works with interfaces:

Here is the interface:

public interface Orderable
{
    int getOrder()
    void setOrder()
}

Here is the worker class:

public class Worker
{
   private List<Orderable> workingList;

   public void setList(List<Orderable> value) {this.workingList=value;}

   public void changePlaces(Orderable o1,Orderable o2)
   {
     // implementation that make o1.order=o2.order and vice versa
   }
}

Here is an object that implements the interface:

public class Cat implements Orderable
{
    private int order;

    public int getOrder()
    {
      return this.order;
    }

    public void setOrder(int value)
    {
      this.order=value;
    }

    public Cat(String name,int order)
    {
       this.name=name;
       this.order=order;
    }
}

In the main procedure I create a list of cats. I use glazed lists to dynamically update controls when the list is changed and when a control model is created with this list.

The goal is to transfer this list to a worker object, so I can add some new cat to the list in the main procedure, and the worker will know about it without setting its list property again (list is same object in main proc and in worker). But when I call worker.setList(cats) it alerts about expecting an Orderable, but getting a Cat... but Cat implements Orderable. How do I solve this?

Here is the main code:

void main()
{
   EventList<Cat> cats=new BasicEventList<Cat>();

   for (int i=0;i<10;i++)
   {
      Cat cat=new Cat("Maroo"+i,i);
      cats.add(cat);
   }

   Worker worker=new Worker(); 
   worker.setList(cats); // wrong!
   // and other very useful code
}

Answer 1

You need to change the Worker class so that it accepts List<? extends Orderable>

public class Worker
{
   private List<? extends Orderable> workingList;

   public void setList(List<? extends Orderable> value) {this.workingList=value;}

   public void changePlaces(Orderable o1,Orderable o2)
   {
     // implementation that make o1.order=o2.order and vice verca  
   }
}

Answer 2

It should work if you just change the declaration of cats:

List<? extends Orderable> cats = new BasicEventList<? extends Orderable>();

for (int i=0; i<10; i++)
{
   cats.add(new Cat("Maroo"+i, i));
}

Worker worker = new Worker(); 
worker.setList(cats);

See:

• Why can't a method take a Collection<subClass> when the method's signature is defined as Collection<class>
• Can I add to a generic collection of type A values of type B ,which extends A, without any special syntax?
• Java Collections: Pass collection of children as collection of parents
• How to cast a list of inheriting objects to a collection of objects in Java?
• and many others...

Answer 3

If you really would like a new collection of the interface type. When for instance you don't own the methods you are calling.

//worker.setList(cats); 
worker.setList( new ArrayList<Orderable>(cats)); //create new collection of interface type based on the elements of the old one

Answer 4

void main()
{
    EventList<Orderable> cats = new BasicEventList<Orderable>();

    for (int i=0;i<10;i++)
    {
        Cat cat=new Cat("Maroo"+i,i);
        cats.add(cat);
    }

    Worker worker=new Worker(); 
    worker.setList(cats); // should be fine now!
    // and other very usefull code
}

Mostly, just construct a list of Orderables right away, since cat implements Orderable, you should be able to add a cat to the list.

note: this is me quickly guessing