Error in Java Generics - Required type: List<MyClass> Provided: List<T>

I have two classes implementing interface

public class MyClassA implements IClassA {
// code
}
public class MyClassB implements IClassB {
// code
}

I have Utility function to convert these classes

public class Util {
public static List<MyClassB> convertAtoB(List<MyClassA> aClasses) {
// logic
}
}

Finally, I have a generic class

public class GenericClass <D extends IClassA, V extends IClassB> {
public List<V> someFunc(List<D> in) {
return Util.convertAtoB(in);   // ERROR HERE
}
}

The error is coming as

Required Type: List<MyClassA> 
Provided: List<D>

What is going wrong ?

EDIT

Here is what I want to achieve

I have many converter functions which convert one type of list to another using some logic. Functions look like below and are in Util class

List<B> convertAtoB(List<A> list) { }
List<C> convertBtoC(List<B> list) { }
List<D> convertCtoD(List<C> list) { }
List<E> convertDtoE(List<D> list) { }
... so on

Now, all these have to be invoked Asynchronously. So, I will use AyncTask for this purpose. Now I have two options:

Option-1: Create multiple classes each extending AsyncTask and calling respective converter function in each of them.

class ConvertAtoBAsync extends AsyncTask<List<MyClassA>, Void, List<MyClassB>> {
public List<MyClassB> doInBackground(List<MyClassA> ...lists) {
return convertAtoB(lists[0]);
}
}
class ConvertBtoCAsync extends AsyncTask<List<MyClassB>, Void, List<MyClassC>> {
public List<MyClassC> doInBackground(List<MyClassB> ...lists) {
return convertBtoC(lists[0]);
}
}
.. so on

Option-2: Create a generic AsyncTask class which can invoke a particular type of converter based on class type

public class ConvertAsync <D extends IClassIn, V extends IClassOut> {
ConvertAsync(Class _class) {  mClass = _class }
public List<V> someFunc(List<D> in) {
if(mClass = MyClassA.class)
return Util.convertAtoB(in);   // ERROR HERE
else if(mClass = MyClassB.class)
return Util.convertBtoC(in);   // ERROR HERE
.. so on
}
}

Can I not achieve using Option-2 ?

With Java Generics, where a List<MyClassA> is expected, you must provide a List of exactly that element type, e.g. an ArrayList<MyClassA>, not e.g. an ArrayList<MySubClassA>.

Additionally, in Util you require the parameter to be a List<MyClassA>, not using the interface IClassA.

So, when you try to pass List<D> to your Util method, the compiler rejects that for two reasons:

• The method requires MyClassA elements, and the List<D> only can only guarantee elements of the interface type IClassA which might as well come from a different MyOtherClassA.
• Even without that difference, a method requiring List<IClassA> will not accept a List<MyClassA>, even given tha fact that MyClassA implements IClassA (see below for rationale).

So you should change the Util method to accept List<? extends IClassA>.

Rationale

Inside the method, you might try to store something into that list. The method sees a type of List<IClassA>, so storing a MyOtherClassA instance would look perfectly okay. But actually you passed in a List<MyClassA>, and now this list gets corrupted with an element not being of type MyClassA. So, Java was designed not to allow that, and the compiler is correct in flagging that as an error situation.

By declaring List<? extends IClassA>, you allow using List<MyClassA> as an actual argument, and at the same time effectively prohibit storing into that list, inside the method.

EDIT:

You added more context to your question. Still, my advice is to modify the Util methods to accept List<? extends IClassA> and similar. That sould be the main element to make Option 2 work.