Android中的java泛型

我不理解以下代码：

public class EventAdapter extends ArrayAdapter<Event> 
{
    public EventAdapter(Context context, int textViewResourceId,
            List<Event> objects) 
    {
        super(context, textViewResourceId, objects);
        this.resource = textViewResourceId;
    }
}

公共类EventAdapter扩展了ArrayAdapter
{
公共事件适配器（上下文上下文，int textViewResourceId，
列出对象）
{
超级（上下文、textViewResourceId、对象）；
this.resource=textViewResourceId；
}
}

我对这两种情况下的

部分感到困惑。我知道这和泛型有关，但我不明白。我读了，但还是不明白

我知道

对象

是

事件类型的对象的
数组列表

我不理解的部分是用
类型扩展ArrayAdapter。这意味着什么？
这是我在这种情况下看待泛型的过于简单的方式。根据定义：

public class EventAdapter extends ArrayAdapter<Event> 

公共类EventAdapter扩展了ArrayAdapter

我将其理解为：“一个
EventAdapter
是
Event
对象的
ArrayAdapter
。”

我把
列表对象
理解为
事件
对象的
列表

集合是对象的容器，而泛型定义它们可以包含的内容。
扩展了ArrayAdapter

这里的类型限制将影响类中方法的返回类型和方法的参数类型

下面是一个示例，如果您有一个类：

class SomeClass<T> {
    protected T value;

    public void setValue (T value) {
        this.value = value;
    }

    public T getValue () {
        return value;
    }
}

如果删除
@Override
注释，它将运行。但是
扩展SomeClass
是无用的，如果您将其保留在那里，可能会导致问题——将有两种非常相似的方法：
setValue（Event）
和
super.setValue（T）
。现在的问题是子类是否可以访问
super.setValue（T）
方法？我将在最后解释它，请参阅“缺少类型参数边界示例”

因此，您需要在声明中指定类型：

class SubClass extends SomeClass<Event> {

    @Override
    public void setValue (Event value) {    // Correct now!
        this.value = value;
    }
}

class子类扩展了SomeClass{
@凌驾
public void setValue（事件值）{//立即更正！
这个值=值；
}
}

此外，如果声明了不一致的类型：

class SubClass extends SomeClass<String> {

    @Override
    public void setValue (Event value) {    // Fail! Not overriding.
        this.value = value;    // Fail! Inconsistent types.
    }
}

class子类扩展了SomeClass{
@凌驾
public void setValue（事件值）{//Fail！未重写。
this.value=value；//失败！类型不一致。
}
}

因此，类型限制了类主体的行为



缺少类型参数边界示例：

import java.lang.reflect.*；
超级班{
公共无效法（T）{
System.out.println（“你好”）；
}
公共无效方法2（）{
}
}
公共类测试扩展了超级{
/*公共无效方法（对象t）{
System.out.println（“世界”）；
}*/
/*公共无效法（T）{
}*/
公共静态void main（字符串参数[]）{
新的Test（）方法（“”）；
对于（方法m:Test.class.getMethods（））{
System.out.println（m.toGenericString（））；
}
}
}


如果我在子类中注释
method（）
，则编译时会发出警告：
Test.java使用未经检查或不安全的操作。在运行结果中，它将泛型类型
T
转换为
Object
：
public void Test.method（java.lang.Object）

如果我只取消注释子类中的第一个
方法（）
，则编译时不会出现警告。在运行结果中，子类拥有一个
公共void Test.method（java.lang.Object）
。但它不允许
@覆盖
注释

如果我只取消注释子类中的第二个
方法（）
（它也具有泛型类型边界），编译将失败，并出现错误：
名称冲突
。它也不允许
@覆盖
注释。如果您这样做，它会抛出一个不同的错误：
方法不重写

method2（）
由子类一致继承。但您也不能编写以下代码：

public class EventAdapter extends ArrayAdapter<Event> 
{
    public EventAdapter(Context context, int textViewResourceId,
            List<Event> objects) 
    {
        super(context, textViewResourceId, objects);
        this.resource = textViewResourceId;
    }
}

在超类中：
public void method2（Object obj）
和子类中：
public void method2（T obj）
。它们也是不明确的，编译器不允许使用

这将为ArrayAdapter中的泛型参数指定一个值，从而剥夺EventAdapter类用户的控制权

在这里重写的任何方法都可以用Event替换T，Event可以代替T而不使用强制转换

这是泛型的一般定义

在这种情况下允许这样做的定义见。虽然在那一节中没有定义确切的行为，但我认为它与我所能看到的所有其他一般行为是一致的

虽然我第一次在这里看到这个结构，但经过一些思考，它真的没有什么不寻常的地方。
那么你不明白什么部分？我认为你需要更清楚一些人们不理解的东西来帮助你。模糊的标题，但问题也是如此。我更新了我的问题，使之更清楚。你可能有兴趣找到我答案的更新——我指出了一个更“本质”的问题。
import java.lang.reflect.*;

class Super<T> {
    public void method (T t) {
        System.out.println("Hello");
    }

    public void method2 () {

    }
}

public class Test extends Super {
    /*public void method (Object t) {
        System.out.println("world");
    }*/

    /*public <T> void method (T t) {

    }*/

    public static void main (String args[]) {
        new Test().method("");
        for (Method m : Test.class.getMethods()) {
            System.out.println(m.toGenericString());
        }
    }
}