¿Crear instancia de tipo genérico en Java?

¿Es posible crear una instancia de tipo genérico en Java? Estoy pensando, según lo que he visto, que la respuesta es no( debido a la eliminación de tipo ), pero me interesaría si alguien puede ver algo que me falta:

class SomeContainer<E>
{
    E createContents()
    {
        return what???
    }
}

EDITAR: Resulta que los Super Type Tokens podrían usarse para resolver mi problema, pero requiere una gran cantidad de código basado en la reflexión, como lo indican algunas de las respuestas a continuación.

Dejaré esto abierto por un tiempo para ver si a alguien se le ocurre algo dramáticamente diferente al Artículo Artima de Ian Robertson .

Estás en lo correcto. No se puede hacer new E(). Pero puedes cambiarlo a

private static class SomeContainer<E> {
    E createContents(Class<E> clazz) {
        return clazz.newInstance();
    }
}

Es un dolor. Pero funciona. Envolverlo en el patrón de fábrica lo hace un poco más tolerable.

No sé si esto ayuda, pero cuando subclases (incluso de forma anónima) un tipo genérico, la información del tipo está disponible a través de la reflexión. p.ej,

public abstract class Foo<E> {

  public E instance;  

  public Foo() throws Exception {
    instance = ((Class)((ParameterizedType)this.getClass().
       getGenericSuperclass()).getActualTypeArguments()[0]).newInstance();
    ...
  }

}

Entonces, cuando subclases Foo, obtienes una instancia de Bar, por ejemplo,

// notice that this in anonymous subclass of Foo
assert( new Foo<Bar>() {}.instance instanceof Bar );

Pero es mucho trabajo y solo funciona para subclases. Aunque puede ser útil.

En Java 8 puede usar la Supplierinterfaz funcional para lograr esto con bastante facilidad:

class SomeContainer<E> {
  private Supplier<E> supplier;

  SomeContainer(Supplier<E> supplier) {
    this.supplier = supplier;
  }

  E createContents() {
    return supplier.get();
  }
}

Construirías esta clase así:

SomeContainer<String> stringContainer = new SomeContainer<>(String::new);

La sintaxis String::newen esa línea es una referencia de constructor .

Si su constructor toma argumentos, puede usar una expresión lambda en su lugar:

SomeContainer<BigInteger> bigIntegerContainer
    = new SomeContainer<>(() -> new BigInteger(1));

Necesitará algún tipo de fábrica abstracta de un tipo u otro para pasar el dinero a:

interface Factory<E> {
    E create();
}

class SomeContainer<E> {
    private final Factory<E> factory;
    SomeContainer(Factory<E> factory) {
        this.factory = factory;
    }
    E createContents() {
        return factory.create();
    }
}

package org.foo.com;

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

/**
 * Basically the same answer as noah's.
 */
public class Home<E>
{

    @SuppressWarnings ("unchecked")
    public Class<E> getTypeParameterClass()
    {
        Type type = getClass().getGenericSuperclass();
        ParameterizedType paramType = (ParameterizedType) type;
        return (Class<E>) paramType.getActualTypeArguments()[0];
    }

    private static class StringHome extends Home<String>
    {
    }

    private static class StringBuilderHome extends Home<StringBuilder>
    {
    }

    private static class StringBufferHome extends Home<StringBuffer>
    {
    }   

    /**
     * This prints "String", "StringBuilder" and "StringBuffer"
     */
    public static void main(String[] args) throws InstantiationException, IllegalAccessException
    {
        Object object0 = new StringHome().getTypeParameterClass().newInstance();
        Object object1 = new StringBuilderHome().getTypeParameterClass().newInstance();
        Object object2 = new StringBufferHome().getTypeParameterClass().newInstance();
        System.out.println(object0.getClass().getSimpleName());
        System.out.println(object1.getClass().getSimpleName());
        System.out.println(object2.getClass().getSimpleName());
    }

}

Si necesita una nueva instancia de un argumento de tipo dentro de una clase genérica, haga que sus constructores exijan su clase ...

public final class Foo<T> {

    private Class<T> typeArgumentClass;

    public Foo(Class<T> typeArgumentClass) {

        this.typeArgumentClass = typeArgumentClass;
    }

    public void doSomethingThatRequiresNewT() throws Exception {

        T myNewT = typeArgumentClass.newInstance();
        ...
    }
}

Uso:

Foo<Bar> barFoo = new Foo<Bar>(Bar.class);
Foo<Etc> etcFoo = new Foo<Etc>(Etc.class);

Pros:

• Mucho más simple (y menos problemático) que el enfoque de Super Type Token (STT) de Robertson.
• Mucho más eficiente que el enfoque STT (que comerá su teléfono celular para el desayuno).

Contras:

• No se puede pasar la clase a un constructor predeterminado (razón por la cual Foo es final). Si realmente necesita un constructor predeterminado, siempre puede agregar un método de establecimiento, pero luego debe recordar llamarlo más tarde.
• La objeción de Robertson ... Más barras que una oveja negra (aunque especificar la clase de argumento de tipo una vez más no te matará exactamente). Y al contrario de lo que afirma Robertson, esto no viola el principio DRY de todos modos porque el compilador asegurará la corrección de tipo.
• No del todo Foo<L>prueba. Para empezar ... newInstance()arrojará un wobbler si la clase de argumento de tipo no tiene un constructor predeterminado. Sin embargo, esto se aplica a todas las soluciones conocidas.
• Carece de la encapsulación total del enfoque STT. Sin embargo, no es un gran problema (considerando la sobrecarga de rendimiento escandaloso de STT).

Puede hacer esto ahora y no requiere un montón de código de reflexión.

import com.google.common.reflect.TypeToken;

public class Q26289147
{
    public static void main(final String[] args) throws IllegalAccessException, InstantiationException
    {
        final StrawManParameterizedClass<String> smpc = new StrawManParameterizedClass<String>() {};
        final String string = (String) smpc.type.getRawType().newInstance();
        System.out.format("string = \"%s\"",string);
    }

    static abstract class StrawManParameterizedClass<T>
    {
        final TypeToken<T> type = new TypeToken<T>(getClass()) {};
    }
}

Por supuesto, si necesita llamar al constructor que requerirá cierta reflexión, pero eso está muy bien documentado, ¡este truco no lo es!

Aquí está el JavaDoc para TypeToken .

Piense en un enfoque más funcional: en lugar de crear un E de la nada (que es claramente un olor a código), pase una función que sepa cómo crear uno, es decir

E createContents(Callable<E> makeone) {
     return makeone.call(); // most simple case clearly not that useful
}

De Java Tutorial - Restricciones sobre genéricos :

No se pueden crear instancias de parámetros de tipo

No puede crear una instancia de un parámetro de tipo. Por ejemplo, el siguiente código provoca un error en tiempo de compilación:

public static <E> void append(List<E> list) {
    E elem = new E();  // compile-time error
    list.add(elem);
}

Como solución alternativa, puede crear un objeto de un parámetro de tipo a través de la reflexión:

public static <E> void append(List<E> list, Class<E> cls) throws Exception {
    E elem = cls.newInstance();   // OK
    list.add(elem);
}

Puede invocar el método append de la siguiente manera:

List<String> ls = new ArrayList<>();
append(ls, String.class);

Aquí hay una opción que se me ocurrió, puede ayudar:

public static class Container<E> {
    private Class<E> clazz;

    public Container(Class<E> clazz) {
        this.clazz = clazz;
    }

    public E createContents() throws Exception {
        return clazz.newInstance();
    }
}

EDITAR: Alternativamente, puede usar este constructor (pero requiere una instancia de E):

@SuppressWarnings("unchecked")
public Container(E instance) {
    this.clazz = (Class<E>) instance.getClass();
}

Si no desea escribir el nombre de la clase dos veces durante la creación de instancias, como en:

new SomeContainer<SomeType>(SomeType.class);

Puedes usar el método de fábrica:

<E> SomeContainer<E> createContainer(Class<E> class); 

Como en:

public class Container<E> {

    public static <E> Container<E> create(Class<E> c) {
        return new Container<E>(c);
    }

    Class<E> c;

    public Container(Class<E> c) {
        super();
        this.c = c;
    }

    public E createInstance()
            throws InstantiationException,
            IllegalAccessException {
        return c.newInstance();
    }

}

Desafortunadamente, Java no permite lo que quieres hacer. Vea la solución oficial :

No puede crear una instancia de un parámetro de tipo. Por ejemplo, el siguiente código provoca un error en tiempo de compilación:

public static <E> void append(List<E> list) {
    E elem = new E();  // compile-time error
    list.add(elem);
}

Como solución alternativa, puede crear un objeto de un parámetro de tipo a través de la reflexión:

public static <E> void append(List<E> list, Class<E> cls) throws Exception {
    E elem = cls.newInstance();   // OK
    list.add(elem);
}

Puede invocar el método append de la siguiente manera:

List<String> ls = new ArrayList<>();
append(ls, String.class);

Cuando trabaja con E en tiempo de compilación, realmente no le importa el tipo genérico real "E" (ya sea que use la reflexión o trabaje con la clase base de tipo genérico), así que deje que la subclase proporcione la instancia de E.

Abstract class SomeContainer<E>
{

    abstract protected  E createContents();
    public doWork(){
        E obj = createContents();
        // Do the work with E 

     }
}


BlackContainer extends SomeContainer<Black>{
    Black createContents() {
        return new  Black();
    }
}

Puedes usar:

Class.forName(String).getConstructor(arguments types).newInstance(arguments)

Pero debe proporcionar el nombre exacto de la clase, incluidos los paquetes, por ejemplo. java.io.FileInputStream. Utilicé esto para crear un analizador de expresiones matemáticas.

¡Espero que no sea demasiado tarde para ayudar!

Java es de tipo seguro, solo Object puede crear una instancia.

En mi caso no puedo pasar parámetros al createContentsmétodo. Mi solución es usar extensiones en lugar de todas las respuestas a continuación.

private static class SomeContainer<E extends Object> {
    E e;
    E createContents() throws Exception{
        return (E) e.getClass().getDeclaredConstructor().newInstance();
    }
}

Este es mi caso de ejemplo que no puedo pasar parámetros.

public class SomeContainer<E extends Object> {
    E object;

    void resetObject throws Exception{
        object = (E) object.getClass().getDeclaredConstructor().newInstance();
    }
}

Usando la reflexión crear error de tiempo de ejecución, si extiende su clase genérica con ningún tipo de objeto. Para extender su tipo genérico a objeto, convierta este error en error de tiempo de compilación.

Usa la TypeToken<T>clase:

public class MyClass<T> {
    public T doSomething() {
        return (T) new TypeToken<T>(){}.getRawType().newInstance();
    }
}

Pensé que podía hacer eso, pero bastante decepcionado: no funciona, pero creo que aún vale la pena compartirlo.

Quizás alguien pueda corregir:

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

interface SomeContainer<E> {
    E createContents();
}

public class Main {

    @SuppressWarnings("unchecked")
    public static <E> SomeContainer<E> createSomeContainer() {
        return (SomeContainer<E>) Proxy.newProxyInstance(Main.class.getClassLoader(),
                new Class[]{ SomeContainer.class }, new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                Class<?> returnType = method.getReturnType();
                return returnType.newInstance();
            }
        });
    }

    public static void main(String[] args) {
        SomeContainer<String> container = createSomeContainer();

    [*] System.out.println("String created: [" +container.createContents()+"]");

    }
}

Produce:

Exception in thread "main" java.lang.ClassCastException: java.lang.Object cannot be cast to java.lang.String
    at Main.main(Main.java:26)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:601)
    at com.intellij.rt.execution.application.AppMain.main(AppMain.java:120)

La línea 26 es la que tiene el [*].

La única solución viable es la de @JustinRudd

Una mejora de la respuesta de @ Noah.

Razón para el cambio

a] Es más seguro si se usa más de 1 tipo genérico en caso de que cambie el orden.

b] Una firma de tipo genérico de clase cambia de vez en cuando para que no se sorprenda con excepciones inexplicables en el tiempo de ejecución.

Código robusto

public abstract class Clazz<P extends Params, M extends Model> {

    protected M model;

    protected void createModel() {
    Type[] typeArguments = ((ParameterizedType) this.getClass().getGenericSuperclass()).getActualTypeArguments();
    for (Type type : typeArguments) {
        if ((type instanceof Class) && (Model.class.isAssignableFrom((Class) type))) {
            try {
                model = ((Class<M>) type).newInstance();
            } catch (InstantiationException | IllegalAccessException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

O usa el forro único

Código de una línea

model = ((Class<M>) ((ParameterizedType) this.getClass().getGenericSuperclass()).getActualTypeArguments()[1]).newInstance();

lo que puedes hacer es

1. Primero declara la variable de esa clase genérica

   2. Luego crea un constructor y crea una instancia de ese objeto

2. Luego úsalo donde quieras usarlo

ejemplo-

1

private Class<E> entity;

2

public xyzservice(Class<E> entity) {
        this.entity = entity;
    }



public E getEntity(Class<E> entity) throws InstantiationException, IllegalAccessException {
        return entity.newInstance();
    }

3)

E e = getEntity (entidad);

Como dijiste, realmente no puedes hacerlo debido a la eliminación de tipo. Puede hacerlo usando la reflexión, pero requiere mucho código y mucho manejo de errores.

Si te refieres, new E() entonces es imposible. Y agregaría que no siempre es correcto: ¿cómo saber si E tiene un constructor público sin argumentos? Pero siempre puede delegar la creación a otra clase que sepa cómo crear una instancia, puede ser Class<E>su código personalizado como este

interface Factory<E>{
    E create();
}    

class IntegerFactory implements Factory<Integer>{    
  private static int i = 0; 
  Integer create() {        
    return i++;    
  }
}

return   (E)((Class)((ParameterizedType)this.getClass().getGenericSuperclass()).getActualTypeArguments()[0]).newInstance();

Puede lograr esto con el siguiente fragmento:

import java.lang.reflect.ParameterizedType;

public class SomeContainer<E> {
   E createContents() throws InstantiationException, IllegalAccessException {
      ParameterizedType genericSuperclass = (ParameterizedType)
         getClass().getGenericSuperclass();
      @SuppressWarnings("unchecked")
      Class<E> clazz = (Class<E>)
         genericSuperclass.getActualTypeArguments()[0];
      return clazz.newInstance();
   }
   public static void main( String[] args ) throws Throwable {
      SomeContainer< Long > scl = new SomeContainer<>();
      Long l = scl.createContents();
      System.out.println( l );
   }
}

Existen varias bibliotecas que pueden resolver Epor usted utilizando técnicas similares a las que discutió el artículo de Robertson. Aquí hay una implementación de createContentsque usa TypeTools para resolver la clase sin procesar representada por E:

E createContents() throws Exception {
  return TypeTools.resolveRawArgument(SomeContainer.class, getClass()).newInstance();
}

Esto supone que getClass () se resuelve en una subclase de SomeContainer y fallará de lo contrario ya que el valor parametrizado real de E se habrá borrado en tiempo de ejecución si no se captura en una subclase.

Aquí hay una implementación de createContentsque usa TypeTools para resolver la clase sin procesar representada por E:

E createContents() throws Exception {
  return TypeTools.resolveRawArgument(SomeContainer.class, getClass()).newInstance();
}

Este enfoque solo funciona si SomeContainerse subclasifica, por lo que el valor real de Ese captura en una definición de tipo:

class SomeStringContainer extends SomeContainer<String>

De lo contrario, el valor de E se borra en tiempo de ejecución y no es recuperable.

Puede con un cargador de clases y el nombre de la clase, eventualmente algunos parámetros.

final ClassLoader classLoader = ...
final Class<?> aClass = classLoader.loadClass("java.lang.Integer");
final Constructor<?> constructor = aClass.getConstructor(int.class);
final Object o = constructor.newInstance(123);
System.out.println("o = " + o);

Aquí hay una solución mejorada, basada en ParameterizedType.getActualTypeArguments, ya mencionada por @noah, @Lars Bohl y algunos otros.

Primera pequeña mejora en la implementación. La fábrica no debe devolver la instancia, sino un tipo. Tan pronto como devuelva la instancia utilizando Class.newInstance(), reduce el alcance de uso. Porque solo los constructores sin argumentos pueden ser invocados de esta manera. Una mejor manera es devolver un tipo y permitir que un cliente elija qué constructor desea invocar:

public class TypeReference<T> {
  public Class<T> type(){
    try {
      ParameterizedType pt = (ParameterizedType) this.getClass().getGenericSuperclass();
      if (pt.getActualTypeArguments() == null || pt.getActualTypeArguments().length == 0){
        throw new IllegalStateException("Could not define type");
      }
      if (pt.getActualTypeArguments().length != 1){
        throw new IllegalStateException("More than one type has been found");
      }
      Type type = pt.getActualTypeArguments()[0];
      String typeAsString = type.getTypeName();
      return (Class<T>) Class.forName(typeAsString);

    } catch (Exception e){
      throw new IllegalStateException("Could not identify type", e);
    }

  }
}

Aquí hay algunos ejemplos de uso. @Lars Bohl ha mostrado solo una forma signe de obtener la genificación reificada a través de la extensión. @noah solo mediante la creación de una instancia con {}. Aquí hay pruebas para demostrar ambos casos:

import java.lang.reflect.Constructor;

public class TypeReferenceTest {

  private static final String NAME = "Peter";

  private static class Person{
    final String name;

    Person(String name) {
      this.name = name;
    }
  }

  @Test
  public void erased() {
    TypeReference<Person> p = new TypeReference<>();
    Assert.assertNotNull(p);
    try {
      p.type();
      Assert.fail();
    } catch (Exception e){
      Assert.assertEquals("Could not identify type", e.getMessage());
    }
  }

  @Test
  public void reified() throws Exception {
    TypeReference<Person> p = new TypeReference<Person>(){};
    Assert.assertNotNull(p);
    Assert.assertEquals(Person.class.getName(), p.type().getName());
    Constructor ctor = p.type().getDeclaredConstructor(NAME.getClass());
    Assert.assertNotNull(ctor);
    Person person = (Person) ctor.newInstance(NAME);
    Assert.assertEquals(NAME, person.name);
  }

  static class TypeReferencePerson extends TypeReference<Person>{}

  @Test
  public void reifiedExtenension() throws Exception {
    TypeReference<Person> p = new TypeReferencePerson();
    Assert.assertNotNull(p);
    Assert.assertEquals(Person.class.getName(), p.type().getName());
    Constructor ctor = p.type().getDeclaredConstructor(NAME.getClass());
    Assert.assertNotNull(ctor);
    Person person = (Person) ctor.newInstance(NAME);
    Assert.assertEquals(NAME, person.name);
  }
}

Nota: se puede obligar a los clientes de TypeReferencesiempre uso {}cuando instancia se crea al hacer esta clase abstracta: public abstract class TypeReference<T>. No lo he hecho, solo para mostrar el caso de prueba borrado.