Инстанцирование дженериков вводит в Java

То, что вы написали, не имеет никакого смысла, дженерики в Java предназначены для добавления функциональности параметрического полиморфизма к объектам.

Что это значит? Это означает, что вы хотите оставить неопределенными некоторые переменные типа ваших классов, чтобы иметь возможность использовать ваши классы с множеством различных типов.

Но ваша переменная типа T является атрибутом, который разрешается во время выполнения, компилятор Java скомпилирует ваш класс, проверяя безопасность типов, не пытаясь узнать, что это за объект T , поэтому он не может позволить вам использовать переменную типа в статическом методе. Тип связан с экземпляром объекта во время выполнения, в то время как public void static main (..) связан с определением класса и в этой области T ничего не означает .

Если вы хотите использовать переменную типа внутри статического метода, вы должны объявить метод как универсальный (это потому, что, как объяснялось, переменные типа класса шаблона связаны с его экземпляр времени выполнения ), а не класс:

class SandBox
{
  public static <T> void myMethod()
  {
     T foobar;
  }
}

это работает, но, конечно, не с методом main , поскольку нет способа вызвать его обычным способом.

РЕДАКТИРОВАТЬ : Проблема в том, что из-за стирания типа только один общий класс компилируется и передается JVM. Средство проверки типов просто проверяет безопасность кода, а затем, поскольку она доказала, что вся общая информация отбрасывается.

Чтобы создать экземпляр T , вам необходимо знать тип T , но это может быть много типов одновременно, поэтому одно решение требует минимального отражения. использовать Class для создания экземпляров новых объектов:

public class SandBox<T>
{
    Class<T> reference;

    SandBox(Class<T> classRef)
    {
        reference = classRef;
    }

    public T getNewInstance()
    {
        try
        {
            return reference.newInstance();
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }

        return null;
    }

    public static void main(String[] args)
    {
        SandBox<String> t = new SandBox<String>(String.class);

        System.out.println(t.getNewInstance().getClass().getName());
    }
}

Конечно, это означает, что тип, который вы хотите создать:

• не является примитивным типом
• , он имеет конструктор по умолчанию

] Чтобы работать с различными типами конструкторов, вам нужно глубже изучить рефлексию.

Обходной путь стирания типа

Вдохновленный ответом @martin , я написал вспомогательный класс, который позволяет мне обойти проблему стирания типа. Используя этот класс (и небольшой уродливый трюк), я могу создать новый экземпляр из типа шаблона:

public abstract class C_TestClass<T > {
    T createTemplateInstance() {
        return C_GenericsHelper.createTemplateInstance( this, 0 );
    }

    public static void main( String[] args ) {
        ArrayList<String > list = 
            new C_TestClass<ArrayList<String > >(){}.createTemplateInstance();
    }
}

Уродливый трюк состоит в том, чтобы сделать класс абстрактным , чтобы пользователь класса вынужден подтипировать его. Здесь я создаю подклассы, добавляя {} после вызова конструктора. Это определяет новый анонимный класс и создает его экземпляр.

После того, как общий класс разбит на подтипы с конкретными типами шаблонов, я могу получить типы шаблонов.

public class C_GenericsHelper {
    /**
     * @param object instance of a class that is a subclass of a generic class
     * @param index index of the generic type that should be instantiated
     * @return new instance of T (created by calling the default constructor)
     * @throws RuntimeException if T has no accessible default constructor
     */
    @SuppressWarnings( "unchecked" )
    public static <T> T createTemplateInstance( Object object, int index ) {
        ParameterizedType superClass = 
            (ParameterizedType )object.getClass().getGenericSuperclass();
        Type type = superClass.getActualTypeArguments()[ index ];
        Class<T > instanceType;
        if( type instanceof ParameterizedType ) {
            instanceType = (Class<T > )( (ParameterizedType )type ).getRawType();
        }
        else {
            instanceType = (Class<T > )type;
        }
        try {
            return instanceType.newInstance();
        }
        catch( Exception e ) {
            throw new RuntimeException( e );
        }
    }
}