Eine Instanz generischen Typs in Java erstellen?

Weiß nich ob das hilft, aber wenn Sie eine Unterklasse (einschließlich anonym) ein generischer Typ, der Typ-Informationen verfügbar, über die Reflexion. z.B.,

public abstract class Foo<E> {

  public E instance;  

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

}

So, wenn Sie eine Unterklasse von Foo ist, erhalten Sie eine Instanz von Bar z.B.,

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

Aber es ist eine Menge Arbeit, und funktioniert nur für Unterklassen. Kann praktisch sein, aber.

InformationsquelleAutor der Antwort noah

In Java 8 können Sie die Lieferant funktionale Schnittstelle zu erreichen, ist das ziemlich einfach:

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

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

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

Würden Sie den Bau dieser Klasse wie folgt aus:

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

Die syntax String::new auf dieser Linie ist eine Konstruktor-Referenz.

Wenn Ihr Konstruktor übernimmt Argumente, die Sie verwenden können einen lambda-Ausdruck statt:

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

InformationsquelleAutor der Antwort Daniel Pryden

Wenn Sie eine neue Instanz einer Typ-argument innerhalb einer generischen Klasse dann Ihre Konstruktoren Nachfrage seiner Klasse...

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

Verwendung:

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

Vorteile:

• Viel einfacher (und unproblematischer) als Robertson ' s Super Type-Token (STT) - Ansatz.
• Viel effizienter als die STT-Ansatz (die Essen wird Ihr Handy zum Frühstück).

Nachteile:

• Nicht passieren können-Klasse einen default-Konstruktor (das ist der Grund, warum Foo final). Wenn Sie wirklich brauchen einen Standard-Konstruktor können Sie immer noch eine setter-Methode, aber dann müssen Sie daran denken, geben Sie Ihr einen Anruf später.
• Robertson ' s Einwand,... Mehr Bars als ein Schwarzes Schaf (obwohl die Angabe des type-Arguments-Klasse ein weiteres mal nicht genau Sie zu töten). Und im Gegensatz zu Robertson behauptet, dass dies nicht gegen die TROCKENE AUFTRAGGEBER sowieso, weil der compiler wird sichergestellt Typ Richtigkeit.
• Nicht ganz Foo<L>Beweis. Für den Anfang... newInstance() werfen einen wobbler, wenn das argument Typ Klasse keinen default-Konstruktor. Dies gilt für sämtliche bekannten Lösungen, aber trotzdem.
• Fehlt die totale Kapselung der STT-Ansatz. Keine große Sache, aber (in Anbetracht der unverschämten performance-overhead von STT).

InformationsquelleAutor der Antwort R2D2M2

Denke über einen mehr funktionalen Ansatz: statt die Entwicklung von einigen E aus dem nichts (und das ist eindeutig ein code smell), übergeben Sie eine Funktion, die weiß, wie man eine zu erstellen, d.h.

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

InformationsquelleAutor der Antwort Ingo

Hier ist eine option, die ich mir ausgedacht habe, vielleicht hilft es:

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

EDIT: Alternativ können Sie verwenden Sie diesen Konstruktor, (aber es ist eine Instanz von E):

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

InformationsquelleAutor der Antwort Mike Stone

Beim arbeiten mit E zur compile-Zeit, die Sie nicht wirklich interessieren, die tatsächlichen generischen Typ "E" (entweder über die Reflexion oder die Arbeit mit der Basis-Klasse generischer Typ) lassen Sie uns also die Unterklasse liefern Instanz von 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();
    }
}

InformationsquelleAutor der Antwort Ira

Java leider nicht erlauben, was Sie tun möchten. Sehen http://docs.oracle.com/javase/tutorial/java/generics/restrictions.html#createObjects

Können Sie erstellen eine Instanz eines type-Parameters. Zum Beispiel, der folgende code führt zu einem compile-Zeit-Fehler:

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

Als Problemumgehung können Sie erstellen ein Objekt vom Typ parameter durch Reflexion:

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

Sie aufrufen können Sie die append-Methode wie folgt:

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

InformationsquelleAutor der Antwort Neepsnikeep

Einer imporovement von @Noah ' s Antwort.

Grund für die Änderung

a] Ist sicherer, wenn mehr als 1 generischer Typ wird verwendet, wenn Sie die Reihenfolge ändern.

b] Eine Klasse generische geben Sie die Signatur ändert sich von Zeit zu Zeit, so dass Sie nicht überrascht sein, unerklärliche Ausnahmen, die in der Laufzeit.

Robusten Code

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

Oder verwenden Sie den liner

Eine Zeile Code

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

InformationsquelleAutor der Antwort zatziky

Wenn du meinst
new E()
dann ist es unmöglich. Und ich möchte hinzufügen, dass es ist nicht immer richtig, wie wollen Sie wissen, ob E ein öffentlich-no-args-Konstruktor?
Aber man kann immer delegieren Schöpfung, um einige der anderen Klasse, die weiß, wie man erstellen Sie eine Instanz - es kann sein Class<E> oder Ihre benutzerdefinierte code wie folgt

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

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

InformationsquelleAutor der Antwort Pavel Feldman

Können Sie erreichen dies mit dem folgenden snippet:

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

InformationsquelleAutor der Antwort bogdan

Hier ist eine Implementierung von createContents verwendet TypeTools zu beheben, die raw-Klasse vertreten durch E:

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

Dieser Ansatz funktioniert nur, wenn SomeContainer ist untergeordnet, so dass der tatsächliche Wert des E ist gefangen in einer Art definition:

class SomeStringContainer extends SomeContainer<String>

Sonst ist der Wert von E wird zur Laufzeit gelöscht und ist nicht wiederherstellbar.

InformationsquelleAutor der Antwort Jonathan