簡單地說，在Java中找不到泛型參數的運行時類型。我建議閱讀關于類型擦除的一章。Java教程更多細節。

這方面的一個流行解決方案是傳遞Class將類型參數轉換為泛型類型的構造函數，例如

class Foo<T> {
    final Class<T> typeParameterClass;

    public Foo(Class<T> typeParameterClass) {
        this.typeParameterClass = typeParameterClass;
    }

    public void bar() {
        // you can access the typeParameterClass here and do whatever you like
    }}

然而，有一個小漏洞：如果您定義Foo類作為抽象類。這意味著必須將類實例化為：

Foo<MyType> myFoo = new Foo<MyType>(){};

(請注意末尾的雙大括號。)

現在您可以檢索T在運行時：

Type mySuperclass = myFoo.getClass().getGenericSuperclass();Type tType = ((ParameterizedType)mySuperclass).getActualTypeArguments()[0];

不過，請注意mySuperclass必須是類定義的超類，實際上定義了T.

它也不是很優雅，但是你必須決定你是否更喜歡。new Foo<MyType>(){}或new Foo<MyType>(MyType.class);在你的密碼里。

例如：

import java.lang.reflect.ParameterizedType;import java.lang.reflect.Type;import java.util.ArrayDeque;import java.util.Deque;
import java.util.NoSuchElementException;/**
 * Captures and silently ignores stack exceptions upon popping.
 */public abstract class SilentStack<E> extends ArrayDeque<E> {
  public E pop() {
    try {
      return super.pop();
    }
    catch( NoSuchElementException nsee ) {
      return create();
    }
  }

  public E create() {
    try {
      Type sooper = getClass().getGenericSuperclass();
      Type t = ((ParameterizedType)sooper).getActualTypeArguments()[ 0 ];

      return (E)(Class.forName( t.toString() ).newInstance());
    }
    catch( Exception e ) {
      return null;
    }
  }}

然后：

public class Main {
    // Note the braces...
    private Deque<String> stack = new SilentStack<String>(){};

    public static void main( String args[] ) {
      // Returns a new instance of String.
      String s = stack.pop();
      System.out.printf( "s = '%s'\n", s );
    }}