我也遇到了同样的问题。我通过下载Collections的源代码找到了答案。在Java框架中进行排序。我使用的答案是在方法中放入<T>泛型，而不是在类定义中。

所以这是可行的:

public class QuickSortArray  {
    public static <T extends Comparable> void quickSort(T[] array, int bottom, int top){
//do it
}

}

当然，在阅读了上面的答案之后，我意识到这将是一个不使用泛型类的可接受的替代方案:

public static void quickSort(Comparable[] array, int bottom, int top){
//do it
}

直到实例化一个类型，Java才知道T是什么。

也许你可以通过调用Clazz<T>.doit(一些东西)来执行静态方法，但听起来你不能。

另一种处理方法是将类型参数放在方法本身中:

static <U> void doIt(U object)

这并不能让你对U有正确的限制，但总比没有好....

因为静态变量由类的所有实例共享。例如，如果你有以下代码

class Class<T> {
  static void doIt(T object) {
    // using T here 
  }
}

T仅在创建实例后可用。但是静态方法甚至可以在实例可用之前使用。因此，泛型类型参数不能在静态方法和变量中引用

我也遇到了同样的问题。我通过下载Collections的源代码找到了答案。在Java框架中进行排序。我使用的答案是在方法中放入<T>泛型，而不是在类定义中。

所以这是可行的:

public class QuickSortArray  {
    public static <T extends Comparable> void quickSort(T[] array, int bottom, int top){
//do it
}

}

当然，在阅读了上面的答案之后，我意识到这将是一个不使用泛型类的可接受的替代方案:

public static void quickSort(Comparable[] array, int bottom, int top){
//do it
}

以下内容会让你更接近目标

class Clazz
{
   public static <U extends Clazz> void doIt(U thing)
   {
   }
}

编辑:更新的例子与更多的细节

public abstract class Thingo 
{

    public static <U extends Thingo> void doIt(U p_thingo)
    {
        p_thingo.thing();
    }

    protected abstract void thing();

}

class SubThingoOne extends Thingo
{
    @Override
    protected void thing() 
    {
        System.out.println("SubThingoOne");
    }
}

class SubThingoTwo extends Thingo
{

    @Override
    protected void thing() 
    {
        System.out.println("SuThingoTwo");
    }

}

public class ThingoTest 
{

    @Test
    public void test() 
    {
        Thingo t1 = new SubThingoOne();
        Thingo t2 = new SubThingoTwo();

        Thingo.doIt(t1);
        Thingo.doIt(t2);

        // compile error -->  Thingo.doIt(new Object());
    }
}

当您为类指定泛型类型时，JVM只知道它是类的实例，而不是定义。每个定义只有参数化类型。

泛型的工作方式类似于c++中的模板，因此您应该首先实例化类，然后使用指定类型的函数。