Buat instance dari tipe generik di Jawa?

Apakah mungkin membuat instance tipe generik di Jawa? Saya berpikir berdasarkan apa yang saya lihat bahwa jawabannya adalah no( karena tipe erasure ), tetapi saya akan tertarik jika ada yang bisa melihat sesuatu yang saya lewatkan:

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

EDIT: Ternyata Token Jenis Super dapat digunakan untuk menyelesaikan masalah saya, tetapi memerlukan banyak kode berbasis refleksi, seperti yang ditunjukkan beberapa jawaban di bawah ini.

Saya akan membiarkan ini terbuka sebentar untuk melihat apakah ada orang yang menemukan sesuatu yang secara dramatis berbeda dari Artikel Artima dari Ian Robertson .

Anda benar. Anda tidak bisa melakukannya new E(). Tapi Anda bisa mengubahnya menjadi

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

Ini menyakitkan. Tapi itu berhasil. Membungkusnya dalam pola pabrik membuatnya sedikit lebih bisa ditoleransi.

Tidak tahu apakah ini membantu, tetapi ketika Anda mensubklasifikasikan (termasuk secara anonim) jenis generik, informasi jenis tersedia melalui refleksi. misalnya,

public abstract class Foo<E> {

  public E instance;  

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

}

Jadi, ketika Anda subkelas Foo, Anda mendapatkan instance dari Bar misalnya,

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

Tapi ini banyak pekerjaan, dan hanya berfungsi untuk subclass. Meskipun bisa berguna.

Di Java 8 Anda dapat menggunakan Supplierantarmuka fungsional untuk mencapai ini dengan cukup mudah:

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

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

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

Anda akan membangun kelas ini seperti ini:

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

Sintaks String::newpada baris itu adalah referensi konstruktor .

Jika konstruktor Anda mengambil argumen, Anda dapat menggunakan ekspresi lambda sebagai gantinya:

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

Anda memerlukan beberapa jenis pabrik abstrak untuk mengoper:

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

}

Jika Anda memerlukan contoh baru dari argumen tipe di dalam kelas generik maka buat konstruktor Anda menuntut kelasnya ...

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

Pemakaian:

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

Pro:

• Jauh lebih sederhana (dan tidak terlalu bermasalah) daripada pendekatan Super Type Token (STT) Robertson.
• Jauh lebih efisien daripada pendekatan STT (yang akan memakan ponsel Anda untuk sarapan).

Cons:

• Tidak dapat meneruskan Kelas ke konstruktor default (itulah sebabnya Foo final). Jika Anda benar-benar membutuhkan konstruktor default, Anda selalu dapat menambahkan metode penyetel tetapi kemudian Anda harus ingat untuk meneleponnya nanti.
• Keberatan Robertson ... Lebih banyak Bar daripada seekor domba hitam (meskipun menentukan kelas argumen tipe sekali lagi tidak akan benar-benar membunuh Anda). Dan bertentangan dengan klaim Robertson, ini tidak melanggar prinsip KERING karena kompiler akan memastikan ketepatan jenis.
• Tidak sepenuhnya Foo<L>bukti. Sebagai permulaan ... newInstance()akan melempar wobbler jika kelas argumen type tidak memiliki konstruktor default. Ini berlaku untuk semua solusi yang diketahui.
• Tidak memiliki enkapsulasi total dari pendekatan STT. Bukan masalah besar (mengingat overhead kinerja STT yang keterlaluan).

Anda dapat melakukan ini sekarang dan tidak memerlukan banyak kode refleksi.

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

Tentu saja jika Anda perlu memanggil konstruktor yang akan memerlukan beberapa refleksi, tetapi itu didokumentasikan dengan sangat baik, trik ini tidak!

Berikut ini adalah JavaDoc untuk TypeToken .

Pikirkan tentang pendekatan yang lebih fungsional: alih-alih membuat beberapa E dari ketiadaan (yang jelas merupakan bau kode), berikan fungsi yang tahu cara membuatnya, yaitu

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

Dari Tutorial Java - Pembatasan Generik :

Tidak Dapat Membuat Contoh Parameter Tipe

Anda tidak dapat membuat turunan dari parameter tipe. Misalnya, kode berikut ini menyebabkan kesalahan waktu kompilasi:

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

Sebagai solusinya, Anda bisa membuat objek parameter tipe melalui refleksi:

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

Anda dapat menggunakan metode append sebagai berikut:

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

Berikut adalah opsi yang saya buat, mungkin membantu:

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: Atau Anda dapat menggunakan konstruktor ini (tetapi membutuhkan instance E):

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

Jika Anda tidak ingin mengetikkan nama kelas dua kali selama instantiation seperti di:

new SomeContainer<SomeType>(SomeType.class);

Anda dapat menggunakan metode pabrik:

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

Seperti di:

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

}

Sayangnya Java tidak mengizinkan apa yang ingin Anda lakukan. Lihat solusi resmi :

Anda tidak dapat membuat turunan dari parameter tipe. Misalnya, kode berikut ini menyebabkan kesalahan waktu kompilasi:

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

Sebagai solusinya, Anda bisa membuat objek parameter tipe melalui refleksi:

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

Anda dapat menggunakan metode append sebagai berikut:

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

Ketika Anda bekerja dengan E pada waktu kompilasi, Anda tidak terlalu peduli dengan tipe generik "E" yang sebenarnya (baik Anda menggunakan refleksi atau bekerja dengan kelas dasar dari tipe generik) jadi biarkan subclass memberikan instance 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();
    }
}

Kamu bisa menggunakan:

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

Tetapi Anda perlu memberikan nama kelas yang tepat, termasuk paket, misalnya. java.io.FileInputStream. Saya menggunakan ini untuk membuat parser ekspresi matematika.

Semoga ini belum terlambat untuk membantu !!!

Java adalah tipe-safety, hanya Object yang bisa membuat instance.

Dalam kasus saya, saya tidak bisa meneruskan parameter ke createContentsmetode. Solusi saya menggunakan ekstensi bukan semua jawaban di bawah.

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

Ini contoh kasus saya yang saya tidak bisa melewati parameter.

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

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

Menggunakan refleksi membuat galat run time, jika Anda memperluas kelas generik Anda tanpa tipe objek. Untuk memperluas tipe generik Anda ke objek, ubah kesalahan ini menjadi kompilasi kesalahan waktu.

Gunakan TypeToken<T>kelas:

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

Saya pikir saya bisa melakukan itu, tetapi cukup kecewa: itu tidak berhasil, tetapi saya pikir itu masih layak untuk dibagikan.

Mungkin seseorang dapat memperbaiki:

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()+"]");

    }
}

Itu menghasilkan:

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)

Jalur 26 adalah satu dengan [*] .

Satu-satunya solusi yang layak adalah solusi oleh @JustinRudd

Sebuah jawaban penting dari jawaban Nuh.

Alasan untuk berubah

Sebuah] aman jika lebih dari 1 jenis generik digunakan jika Anda mengubah urutan.

b] Tanda tangan tipe generik kelas berubah dari waktu ke waktu sehingga Anda tidak akan terkejut dengan pengecualian yang tidak dijelaskan dalam runtime.

Kode yang Kuat

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

Atau gunakan liner satu

Kode Satu Baris

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

apa yang bisa kamu lakukan adalah -

1. Pertama mendeklarasikan variabel kelas generik itu

   2.Kemudian buatlah konstruktor dan buat objek itu

2. Kemudian gunakan di mana pun Anda ingin menggunakannya

contoh-

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

Seperti yang Anda katakan, Anda tidak dapat benar-benar melakukannya karena penghapusan tipe. Anda dapat mengurutkannya menggunakan refleksi, tetapi membutuhkan banyak kode dan banyak penanganan kesalahan.

Jika Anda maksud new E() maka itu tidak mungkin. Dan saya akan menambahkan bahwa itu tidak selalu benar - bagaimana Anda tahu jika E memiliki konstruktor tanpa argumen publik? Tetapi Anda selalu dapat mendelegasikan kreasi ke beberapa kelas lain yang tahu cara membuat instance - bisa Class<E>atau kode kustom Anda seperti ini

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

Anda dapat mencapai ini dengan cuplikan berikut:

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

Ada berbagai perpustakaan yang dapat menyelesaikan Euntuk Anda menggunakan teknik yang mirip dengan apa yang dibahas artikel Robertson. Inilah implementasi createContentsyang menggunakan TypeTools untuk menyelesaikan kelas mentah yang diwakili oleh E:

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

Ini mengasumsikan bahwa getClass () memutuskan ke subkelas SomeContainer dan akan gagal jika tidak karena nilai parameter aktual E akan dihapus saat runtime jika tidak ditangkap dalam subkelas.

Berikut ini adalah implementasi dari createContentsyang menggunakan TypeTools untuk menyelesaikan kelas mentah yang diwakili oleh E:

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

Pendekatan ini hanya berfungsi jika SomeContainerdisubklasifikasikan sehingga nilai aktual Editangkap dalam definisi tipe:

class SomeStringContainer extends SomeContainer<String>

Kalau tidak, nilai E dihapus saat runtime dan tidak dapat dipulihkan.

Anda bisa dengan classloader dan nama kelas, akhirnya beberapa parameter.

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

Berikut adalah solusi yang ditingkatkan, berdasarkan ParameterizedType.getActualTypeArguments, sudah disebutkan oleh @noah, @Lars Bohl, dan beberapa lainnya.

Peningkatan kecil pertama dalam implementasi. Pabrik tidak boleh mengembalikan instance, tetapi tipe. Segera setelah Anda kembali contoh menggunakan Class.newInstance()Anda mengurangi ruang lingkup penggunaan. Karena hanya konstruktor tanpa argumen yang dapat dipanggil seperti ini. Cara yang lebih baik adalah mengembalikan tipe, dan mengizinkan klien untuk memilih, konstruktor mana yang ingin dia panggil:

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

  }
}

Berikut adalah contoh penggunaannya. @ Lars Bohl hanya menunjukkan cara signe untuk mendapatkan genenerik terverifikasi melalui ekstensi. @noah hanya melalui membuat instance dengan {}. Berikut adalah tes untuk menunjukkan kedua kasus:

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

Catatan: Anda dapat memaksa klien TypeReferenceselalu digunakan {}ketika misalnya dibuat dengan membuat kelas ini abstrak: public abstract class TypeReference<T>. Saya belum melakukannya, hanya untuk menunjukkan test case terhapus.