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

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

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

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

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

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

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

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

static <U> void doIt(U object)

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

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

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

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

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

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