还有一个Java泛型问题

有人能解释一下为什么下面的方法不起作用吗？它抱怨说：

类型列表中的add（C）方法不适用于参数（Generics.Person）

import java.util.ArrayList；
导入java.util.List；
公共类泛型{
静态类人员实现可比较{
公共最终字符串名称，城市；
公众人物（字符串名称、字符串城市）{
this.name=名称；
this.city=城市；
}
@凌驾
公共int比较对象（该人）{
返回0；
}
}
公共仿制药（）{
List persons=new ArrayList（）；
人员。添加（新人员（空，空））；
}
//然而，这一个有效，但它给出了一个警告
//关于作为原始类型
公共仿制药（）{
List persons=new ArrayList（）；
人员。添加（新人员（空，空））；
}
}

因此，基本上，我想要的是一个通用的

列表，其中包含
可比较的
，我可以向其中添加实现
可比较的
的任何类型。您声明的
列表是一个
C
的列表（其中
C
是您传入的通用类型参数）不过，您正试图直接向其中添加一名
学生。这是行不通的，因为列表可能不是
Student
s

如果您知道该列表将属于
Student
s，则将其声明为（
List
），如果不知道，则需要将
C
传递到您的方法中，然后直接将其添加。
您声明的
List
是
C
的列表（其中
C
是您传递的通用类型参数。）不过，您正试图直接向其中添加一名
学生。这是行不通的，因为列表可能不是
Student
s

如果您知道列表将是
Student
s，然后将其声明为这样（
List
），如果不知道，则需要将
C
传递给您的方法，然后直接添加该方法。
要允许您执行需要执行的操作，您应该从外部指定
泛型
类的类型参数：

Generics<Person> generic = new Generics<Person>();

因为
Place
也是一个有效的候选者。那么类型变量
C
的类型是什么？请注意，没有统一过程会根据您添加到列表中的内容来尝试猜测正确的
C
，最后，您应该看到
C
不是“只要满足约束的任何类型”，而是“满足约束的指定类型”，
要允许执行您需要执行的操作，您应该从外部指定
泛型
类的类型参数：

Generics<Person> generic = new Generics<Person>();

因为
Place
也是一个有效的候选者。那么类型变量
C
的类型是什么？请注意，没有统一过程会根据您添加到列表中的内容尝试猜测正确的
C
，最后您应该看到
C
不是“只要满足约束的任何类型”，而是“满足约束的指定类型”
Ok，所以，问题是您使用泛型的方式不正确（显然，这是编译器所抱怨的）。在你的构造函数中，你说你有一个列表，它将接受C类型的对象。然而，Person不是C类型的！或者不一定。假设您创建了一个新的泛型实例，如下所示：

Generics<Integer> foo = new Generics<Integer>();

Generics foo=new泛型（）；

这是合法的，因为整数确实扩展了可比性。但是，您需要想象这将导致构造函数中的第一行代码“被翻译”为

List persons=new ArrayList（）；

显然，您不能将Person对象添加到此列表；）

以下代码就像一个符咒：

import java.util.ArrayList;
import java.util.List;

public class Generics<C extends Comparable<C>> {

    static class Person implements Comparable<Person> 
    {
        public final String name, city;

        public Person(String name, String city) 
        {
            this.name = name;
            this.city = city;
        }

        @Override
        public int compareTo(Person that) 
        {
            return 0;
        }
    }

    private List<C> _persons = null;

    public Generics() 
    {
        _persons = new ArrayList<C>();
    }

    public void add(C obj)
    {
        _persons.add(obj);
    }

    public static void foo()
    {
        Generics<Person> ppl = new Generics<Person>();
        ppl.add(new Person(null, null));
    }
}

import java.util.ArrayList；
导入java.util.List；
公共类泛型{
静态类人员实现可比较
{
公共最终字符串名称，城市；
公众人物（字符串名称、字符串城市）
{
this.name=名称；
this.city=城市；
}
@凌驾
公共int比较对象（该人）
{
返回0；
}
}
私人列表_persons=null；
公共仿制药（）
{
_persons=newarraylist（）；
}
公共无效添加（C obj）
{
_新增（obj）；
}
公共静态void foo（）
{
泛型ppl=新泛型（）；
ppl.add（新人员（空，空））；
}
}

我不太清楚，希望你明白我的意思
 好的，问题是您使用泛型的方式不正确（显然，这正是编译器所抱怨的）。在你的构造函数中，你说你有一个列表，它将接受C类型的对象。然而，Person不是C类型的！或者不一定。假设您创建了一个新的泛型实例，如下所示：

Generics<Integer> foo = new Generics<Integer>();

Generics foo=new泛型（）；

这是合法的，因为整数确实扩展了可比性。但是，您需要想象这将导致构造函数中的第一行代码“被翻译”为

List persons=new ArrayList（）；

显然，您不能将Person对象添加到此列表；）

以下代码就像一个符咒：

import java.util.ArrayList;
import java.util.List;

public class Generics<C extends Comparable<C>> {

    static class Person implements Comparable<Person> 
    {
        public final String name, city;

        public Person(String name, String city) 
        {
            this.name = name;
            this.city = city;
        }

        @Override
        public int compareTo(Person that) 
        {
            return 0;
        }
    }

    private List<C> _persons = null;

    public Generics() 
    {
        _persons = new ArrayList<C>();
    }

    public void add(C obj)
    {
        _persons.add(obj);
    }

    public static void foo()
    {
        Generics<Person> ppl = new Generics<Person>();
        ppl.add(new Person(null, null));
    }
}

import java.util.ArrayList；
导入java.util.List；
公共类泛型{
静态类人员实现可比较
{
公共最终字符串名称，城市；
公众人物（字符串名称、字符串城市）
{
this.name=名称；
this.city=城市；
}
@凌驾
公共int比较对象（该人）
{
返回0；
}
}
私人列表_persons=null；
公共仿制药（）
{
_persons=newarraylist（）；
}
公共无效添加（C obj）
{
_新增（obj）；
}
公共静态void foo（）
{
泛型ppl=新泛型（）；
ppl.add（新人员（空，空））；
}
}