T不在静态方法的范围内，因此不能在静态方法中使用T。您需要为静态方法定义一个不同的类型参数。我会这样写:

class Clazz<T> {

  static <U> void doIt(U object) {
    // ...
  }

}

例如:

public class Tuple<T> {

    private T[] elements;

    public static <E> Tuple<E> of(E ...args){
        if (args.length == 0) 
             return new Tuple<E>();
        return new Tuple<E>(args);
    }

    //other methods
}

我认为这个语法还没有被提到(在你想要一个没有参数的方法的情况下):

class Clazz {
  static <T> T doIt() {
    // shake that booty
  }
}

还有呼唤:

String str = Clazz.<String>doIt();

希望这能帮助到一些人。

错误中正确地提到:您不能对非静态类型T进行静态引用。原因是类型参数T可以被任何类型参数替换，例如Clazz<String>或Clazz<integer>等。但是静态字段/方法由类的所有非静态对象共享。

以下内容摘自纪录片:

A class's static field is a class-level variable shared by all non-static objects of the class. Hence, static fields of type parameters are not allowed. Consider the following class: public class MobileDevice<T> { private static T os; // ... } If static fields of type parameters were allowed, then the following code would be confused: MobileDevice<Smartphone> phone = new MobileDevice<>(); MobileDevice<Pager> pager = new MobileDevice<>(); MobileDevice<TabletPC> pc = new MobileDevice<>(); Because the static field os is shared by phone, pager, and pc, what is the actual type of os? It cannot be Smartphone, Pager, and TabletPC at the same time. You cannot, therefore, create static fields of type parameters.

正如chris在他的回答中正确指出的那样，在这种情况下，你需要与方法一起使用类型参数，而不是与类一起使用。你可以这样写:

static <E> void doIt(E object) 

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

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

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

Also to put it in simple terms, it happens because of the "Erasure" property of the generics.Which means that although we define ArrayList<Integer> and ArrayList<String> , at the compile time it stays as two different concrete types but at the runtime the JVM erases generic types and creates only one ArrayList class instead of two classes. So when we define a static type method or anything for a generic, it is shared by all instances of that generic, in my example it is shared by both ArrayList<Integer> and ArrayList<String> .That's why you get the error.A Generic Type Parameter of a Class Is Not Allowed in a Static Context!

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

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());
    }
}