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

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

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!

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

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

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

还有呼唤:

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

希望这能帮助到一些人。

@BD at Rivenhill:由于这个老问题在去年重新引起了关注，让我们继续讨论一下，只是为了讨论。 doIt方法的主体根本不做任何t特定的事情。下面就是:

public class Clazz<T> {
  static <T> void doIt(T object) {
    System.out.println("shake that booty '" + object.getClass().toString()
                       + "' !!!");
  }
// ...
}

所以你可以完全放弃所有类型变量，只写代码

public class Clazz {
  static void doIt(Object object) {
    System.out.println("shake that booty '" + object.getClass().toString()
                       + "' !!!");
  }
// ...
}

好的。让我们回到最开始的问题。类声明中的第一个类型变量是多余的。只需要关于方法的第二个步骤。我们又来了，但这还不是最终答案:

public class Clazz  {
  static <T extends Saying> void doIt(T object) {
    System.out.println("shake that booty "+ object.say());
  }

  public static void main(String args[]) {
    Clazz.doIt(new KC());
    Clazz.doIt(new SunshineBand());
  }
}
// Output:
// KC
// Sunshine

interface Saying {
      public String say();
}

class KC implements Saying {
      public String say() {
          return "KC";
      }
}

class SunshineBand implements Saying {
      public String say() {
          return "Sunshine";
      }
}

然而，这太小题大做了，因为下面的版本以同样的方式工作。它所需要的只是方法参数上的接口类型。任何地方都看不到类型变量。这真的是最初的问题吗?

public class Clazz  {
  static void doIt(Saying object) {
    System.out.println("shake that booty "+ object.say());
  }

  public static void main(String args[]) {
    Clazz.doIt(new KC());
    Clazz.doIt(new SunshineBand());
  }
}

interface Saying {
      public String say();
}

class KC implements Saying {
      public String say() {
          return "KC";
      }
}

class SunshineBand implements Saying {
      public String say() {
          return "Sunshine";
      }
}