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

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

还有呼唤:

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

希望这能帮助到一些人。

不能在静态方法或静态字段中使用类的泛型类型参数。类的类型参数只在实例方法和实例字段的范围内。对于静态字段和静态方法，它们在类的所有实例之间共享，甚至是不同类型参数的实例，因此显然它们不能依赖于特定的类型参数。

您的问题似乎不需要使用类的类型参数。如果你能更详细地描述你想要做的事情，也许我们可以帮助你找到更好的方法。

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

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

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

static <U> void doIt(U object)

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

@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";
      }
}

我也遇到了同样的问题。我通过下载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
}

错误中正确地提到:您不能对非静态类型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)