Java泛型中的错误-必需类型：List<；MyClass>；提供：列表<；T>；_Java_Generics

Java泛型中的错误-必需类型：List<；MyClass>；提供：列表<；T>；

java generics

Java泛型中的错误-必需类型：List<；MyClass>；提供：列表<；T>；,java,generics,Java,Generics,我有两个类实现这个接口 public class MyClassA implements IClassA { // code } public class MyClassB implements IClassB { // code } 我有一个实用函数来转换这些类 public class Util { public static List<MyClassB> convertAtoB(List<MyClassA> aClasses) {

我有两个类实现这个接口

public class MyClassA implements IClassA {
   // code
}

public class MyClassB implements IClassB {
   // code
}

我有一个实用函数来转换这些类

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

公共类Util{
公共静态列表转换器B（列表aClasses）{
//逻辑
}
}

最后，我有一个泛型类

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

公共类GenericClass{
公共列表someFunc（中的列表）{
返回Util.convertAtoB（in）；//此处出错
}
}

错误就在眼前

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

所需类型：列表
提供：清单

出了什么问题？

编辑

这就是我想要实现的目标

我有许多转换函数，它们使用某种逻辑将一种类型的列表转换为另一种类型。函数如下所示，位于Util类中

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

List-convertAtoB（List-List）{
列表转换BTOC（列表）{}
列表转换CTOD（列表）{}
List convertDtoE（List List）{}
... 等等

现在，所有这些都必须异步调用。因此，我将使用AyncTask实现此目的。现在我有两个选择：

选项1:创建多个类，每个类扩展异步任务并在每个类中调用相应的转换器函数

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

类ConvertAtoBAsync扩展异步任务{
公共列表背景（列表…列表）{
返回convertAtoB（列表[0]）；
}
}
类ConvertBtoCAsync扩展了AsyncTask{
公共列表背景（列表…列表）{
返回convertboc（列表[0]）；
}
}
.. 等等

选项2:创建一个通用AsyncTask类，该类可以根据类类型调用特定类型的转换器

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
        }
    }

公共类ConvertAsync{
ConvertAsync（类_类）{mClass=_类}
公共列表someFunc（中的列表）{
if（mClass=MyClassA.class）
返回Util.convertAtoB（in）；//此处出错
else if（mClass=MyClassB.class）
返回Util.convertBtoC（in）；//此处出错
…等等
}
}

我不能使用Option-2实现吗？

对于Java泛型，如果需要

列表

，则必须提供该元素类型的

列表

，例如

数组列表

，而不是

数组列表

此外，在

Util

中，您需要参数是

列表

，而不是使用接口

IClassA

因此，当您尝试将

List

传递给

Util

方法时，编译器会出于两个原因拒绝该方法：

该方法需要
```
MyClassA
```
元素，而
```
列表
```
只能保证接口类型
```
IClassA
```
的元素，这些元素也可能来自不同的
```
MyOtherClassA
```
即使没有这种差异，要求
```
List
```
的方法也不会接受
```
List
```
，即使
```
MyClassA
```
实现了
```
IClassA
```
（基本原理见下文）

因此，您应该将

Util

方法更改为使用Java泛型接受

List，如果需要List
，则必须提供该元素类型的List
，例如ArrayList
，而不是ArrayList

此外，在Util
中，您需要参数是列表
，而不是使用接口IClassA

因此，当您尝试将List
传递给Util
方法时，编译器会出于两个原因拒绝该方法：

该方法需要MyClassA
元素，而列表
只能保证接口类型IClassA
的元素，这些元素也可能来自不同的MyOtherClassA
即使没有这种差异，要求List
的方法也不会接受List
，即使MyClassA
实现了IClassA
（基本原理见下文）

因此，您应该将Util
方法更改为接受ListWell，因为您给出了错误的参数，编译器对此不满意。我不知道为什么您会认为未绑定的泛型类型参数D
与MyClassA
相同？D
is-AIClassA
和MyClassA
is-AIClassA
，但这并不意味着您可以在需要MyClassA
的地方传递D
IClassA
可以有许多其他的实现。@Kayaman有一个额外的代码来了解类型。如果类型是MyClassA，则将调用上述代码，否则将调用其他代码，以此类推。。不能这样做吗？你需要解释你想要实现什么。是的，显然这样做是不安全的，但是如果你相信使用了正确的转换器，你可以强制转换列表。好吧，你给出了错误的参数，编译器对此不满意。我不知道为什么您会认为未绑定的泛型类型参数D
与MyClassA
相同？D
is-AIClassA
和MyClassA
is-AIClassA
，但这并不意味着您可以在需要MyClassA
的地方传递D
IClassA
可以有许多其他的实现。@Kayaman有一个额外的代码来了解类型。如果类型是MyClassA，则将调用上述代码，否则将调用其他代码，以此类推。。不能这样做吗？你需要解释你想要实现什么。是的，这样做显然是不安全的，但是如果你相信使用了正确的转换器，你可以强制转换列表。这里还有很多例子/解释：-你的方法convertAtoB（list aclass）
是不变的，但你希望它是“协变的”如上所述，这里还有更多的细节和大量的示例/解释：-您的方法convertAtoB(