blocks|key|3056046|text|看起来你试图创建一个类作为你的应用程序的入口点，但是这是行不通的……当JVM在您启动应用程序时被实例化时，它将不知道它应该使用什么类型。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3056047|但是，如果这是更一般的情况，那么应该是您正在寻找的内容：|3056048|public+MyGeneric<MyChoiceOfType>+getMeAGenericObject(){
+++return+new+MyGeneric<MyChoiceOfType>();
}|code-block|syntax|javascript|3056049|或者：|3056050|MyGeneric<String>+objMyObject+=+new+MyGeneric<String>();|3056051|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

It looks like you are trying to create the class that serves as the entry point to your application as a generic, and that won't work... The JVM won't know what type it is supposed to be using when it's instantiated as you start the application.

However, if this were the more general case, then something like would be what you're looking for:

<pre><code>public MyGeneric&lt;MyChoiceOfType&gt; getMeAGenericObject(){
 return new MyGeneric&lt;MyChoiceOfType&gt;();
}
</code></pre>

or perhaps:

<pre><code>MyGeneric&lt;String&gt; objMyObject = new MyGeneric&lt;String&gt;();
</code></pre>

blocks|key|314462|text|Abc<String>+abcInstance+=+new+Abc<String>+();|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|314463|..for示例|unstyled|314464|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>Abc&lt;String&gt; abcInstance = new Abc&lt;String&gt; ();
</code></pre>

..for example

blocks|key|3056108|text|您似乎不了解泛型是如何工作的。你可能想看看http://java.sun.com/j2se/1.5.0/docs/guide/language/generics.html，你能做的基本上是|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3056109|public+class+Abc<T>
{
++T+someGenericThing;
++public+Abc(){}
++public+T+getSomeGenericThing()
++{
+++++return+someGenericThing;
++}

++public+static+void+main(String[]+args)
++{
+++++//+create+an+instance+of+"Abc+of+String"
++++++++Abc<String>+stringAbc+=+new+Abc<String>();
++++++++String+test+=+stringAbc.getSomeGenericThing();
++}

}+|code-block|syntax|javascript|3056110|entityMap|0|LINK|mutability|MUTABLE|url|http://java.sun.com/j2se/1.5.0/docs/guide/language/generics.html^0|L|1S|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

You don't seem to understand how Generics work.
You may want to look at <a href="http://java.sun.com/j2se/1.5.0/docs/guide/language/generics.html" rel="nofollow noreferrer">http://java.sun.com/j2se/1.5.0/docs/guide/language/generics.html</a>
Basically what you could do is something like

<pre><code>public class Abc&lt;T&gt;
{
 T someGenericThing;
 public Abc(){}
 public T getSomeGenericThing()
 {
 return someGenericThing;
 }

 public static void main(String[] args)
 {
 // create an instance of "Abc of String"
 Abc&lt;String&gt; stringAbc = new Abc&lt;String&gt;();
 String test = stringAbc.getSomeGenericThing();
 }

} 
</code></pre>

blocks|key|311565|text|在您发布的代码中，不可能创建T的实例，因为您不知道它是什么类型：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|311566|public+class+Abc<T>
{
+++++++public+T+getInstanceOfT()
+++++++{
+++++++++++//+There+is+no+way+to+create+an+instance+of+T+here
+++++++++++//+since+we+don't+know+its+type
+++++++}
}+|code-block|syntax|javascript|311567|当然，如果您有一个对Class<T>的引用，并且T有一个默认的构造函数，那么只需在Class对象上调用newInstance()即可。|311568|如果你将Abc<T>子类化，你甚至可以绕过类型擦除问题，而不需要传递任何Class<T>引用：|311569|import+java.lang.reflect.ParameterizedType;

public+class+Abc<T>
{
++++T+getInstanceOfT()
++++{
++++++++ParameterizedType+superClass+=+(ParameterizedType)+getClass().getGenericSuperclass();
++++++++Class<T>+type+=+(Class<T>)+superClass.getActualTypeArguments()[0];
++++++++try
++++++++{
++++++++++++return+type.newInstance();
++++++++}
++++++++catch+(Exception+e)
++++++++{
++++++++++++//+Oops,+no+default+constructor
++++++++++++throw+new+RuntimeException(e);
++++++++}
++++}

++++public+static+void+main(String[]+args)
++++{
++++++++String+instance+=+new+SubClass().getInstanceOfT();
++++++++System.out.println(instance.getClass());
++++}
}

class+SubClass
++++extends+Abc<String>
{
}|311570|entityMap^0|E|1|0|0|A|8|O|1|15|5|1F|D|0|4|6|10|8|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|W|8|@$9|X|A|Y|B|C]|$9|Z|A|10|B|C]|$9|11|A|12|B|C]|$9|13|A|14|B|C]]|D|@]|E|$]]|$1|M|3|N|5|6|7|15|8|@$9|16|A|17|B|C]|$9|18|A|19|B|C]]|D|@]|E|$]]|$1|O|3|P|5|H|7|1A|8|@]|D|@]|E|$I|J]]|$1|Q|3|-4|5|6|7|1B|8|@]|D|@]|E|$]]]|R|$]]

In the code you posted, it's impossible to create an instance of <code>T</code> since you don't know what type that is:

<pre><code>public class Abc&lt;T&gt;
{
 public T getInstanceOfT()
 {
 // There is no way to create an instance of T here
 // since we don't know its type
 }
} 
</code></pre>

Of course it is possible if you have a reference to <code>Class&lt;T&gt;</code> and <code>T</code> has a default constructor, just call <code>newInstance()</code> on the <code>Class</code> object.

If you subclass <code>Abc&lt;T&gt;</code> you can even work around the type erasure problem and won't have to pass any <code>Class&lt;T&gt;</code> references around:

<pre><code>import java.lang.reflect.ParameterizedType;

public class Abc&lt;T&gt;
{
 T getInstanceOfT()
 {
 ParameterizedType superClass = (ParameterizedType) getClass().getGenericSuperclass();
 Class&lt;T&gt; type = (Class&lt;T&gt;) superClass.getActualTypeArguments()[0];
 try
 {
 return type.newInstance();
 }
 catch (Exception e)
 {
 // Oops, no default constructor
 throw new RuntimeException(e);
 }
 }

 public static void main(String[] args)
 {
 String instance = new SubClass().getInstanceOfT();
 System.out.println(instance.getClass());
 }
}

class SubClass
 extends Abc&lt;String&gt;
{
}
</code></pre>

blocks|key|314519|text|您所写的没有任何意义，Java中的泛型旨在为对象添加参数多态功能。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|314520|什么意思？这意味着您希望保留类的一些类型变量，以便能够将您的类与许多不同的类型一起使用。|314521|但是你的类型变量T是一个在运行时解析的属性，Java编译器将编译你的类来证明类型安全，而不会试图知道哪种对象是T，所以它不可能让你在静态方法中使用类型变量。该类型与对象的运行时实例相关联，而public+void+static+main(..)与类定义相关联，在该作用域中，T没有任何意义。|offset|length|style|CODE|314522|如果要在静态方法中使用类型变量，则必须将该方法声明为泛型(这是因为，如前所述，模板类的类型变量与其运行时实例相关)，而不是类：|BOLD|314523|class+SandBox
{
++public+static+<T>+void+myMethod()
++{
+++++T+foobar;
++}
}|code-block|syntax|javascript|314524|这是可行的，但当然不适用于main方法，因为无法以泛型的方式调用它。|314525|JVM编辑:问题是由于类型擦除，只编译了一个泛型类并将其传递给。类型检查器只检查代码是否安全，然后因为它证明了它，所以所有类型的泛型信息都会被丢弃。|314526|要实例化T，您需要知道T的类型，但它可以同时是多个类型，因此只需要最少反射的一种解决方案是使用Class<T>实例化新对象：|314527|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());
++++}
}|314528|当然，这意味着您要实例化的类型：|314529|314530|不是|unordered-list-item|314531|的基元类型，它具有默认构造函数|314532|314533|要使用不同类型的构造函数，您必须更深入地研究反射。|314534|entityMap^0|0|0|8|1|1J|1|2N|R|3T|1|0|1D|5|0|0|D|4|0|V|17|0|0|1Q|4|1|B|1|1B|8|0|0|0|G|0|0|0|2|0|0|F|0|0|0|P|0^^$0|@$1|2|3|4|5|6|7|1C|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1D|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1E|8|@$F|1F|G|1G|H|I]|$F|1H|G|1I|H|I]|$F|1J|G|1K|H|I]|$F|1L|G|1M|H|I]]|9|@]|A|$]]|$1|J|3|K|5|6|7|1N|8|@$F|1O|G|1P|H|L]]|9|@]|A|$]]|$1|M|3|N|5|O|7|1Q|8|@]|9|@]|A|$P|Q]]|$1|R|3|S|5|6|7|1R|8|@$F|1S|G|1T|H|I]]|9|@]|A|$]]|$1|T|3|U|5|6|7|1U|8|@$F|1V|G|1W|H|L]]|9|@]|A|$]]|$1|V|3|W|5|6|7|1X|8|@$F|1Y|G|1Z|H|L]|$F|20|G|21|H|I]|$F|22|G|23|H|I]|$F|24|G|25|H|I]]|9|@]|A|$]]|$1|X|3|Y|5|O|7|26|8|@]|9|@]|A|$P|Q]]|$1|Z|3|10|5|6|7|27|8|@$F|28|G|29|H|L]]|9|@]|A|$]]|$1|11|3|-4|5|6|7|2A|8|@]|9|@]|A|$]]|$1|12|3|13|5|14|7|2B|8|@$F|2C|G|2D|H|L]]|9|@]|A|$]]|$1|15|3|16|5|14|7|2E|8|@$F|2F|G|2G|H|L]]|9|@]|A|$]]|$1|17|3|-4|5|6|7|2H|8|@]|9|@]|A|$]]|$1|18|3|19|5|6|7|2I|8|@$F|2J|G|2K|H|L]]|9|@]|A|$]]|$1|1A|3|-4|5|6|7|2L|8|@]|9|@]|A|$]]]|1B|$]]

What you wrote doesn't make any sense, generics in Java are meant to add the functionality of parametric polymorphism to objects.

What does it mean? It means that you want to keep some type variables of your classes undecided, to be able to use your classes with many different types. 

But your type variable <code>T</code> is an attribute that is resolved at run-time, the Java compiler will compile your class proving type safety without trying to know what kind of object is <code>T</code> so it's impossible for it to let your use a type variable in a static method. The type is associated to a run-time instance of the object while <code>public void static main(..)</code> is associated to the class definition and at that scope <code>T</code> doesn't mean anything.

If you want to use a type variable inside a static method you have to declare the method as generic (this because, as explained type variables of a template class are related to its run-time instance), not the class:

<pre><code>class SandBox
{
 public static &lt;T&gt; void myMethod()
 {
 T foobar;
 }
}
</code></pre>

this works, but of course not with <code>main</code> method since there's no way to call it in a generic way.

EDIT: The problem is that because of type erasure just one generic class is compiled and passed to JVM. Type checker just checks if code is safe, then since it proved it every kind of generic information is discarded.

To instantiate <code>T</code> you need to know the type of <code>T</code>, but it can be many types at the same time, so one solution with requires just the minimum amount of reflection is to use <code>Class&lt;T&gt;</code> to instantiate new objects:

<pre><code>public class SandBox&lt;T&gt;
{
 Class&lt;T&gt; reference;

 SandBox(Class&lt;T&gt; classRef)
 {
 reference = classRef;
 }

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

 return null;
 }

 public static void main(String[] args)
 {
 SandBox&lt;String&gt; t = new SandBox&lt;String&gt;(String.class);

 System.out.println(t.getNewInstance().getClass().getName());
 }
}
</code></pre>

Of course this implies that the type you want to instantiate:

<ul>
<li>is not a primitive type</li>
<li>it has a default constructor</li>
</ul>

To operate with different kind of constructors you have to dig deeper into reflection.

blocks|key|3269789|text|首先，您不能在静态main方法中访问类型参数T，只能在非静态类成员上访问(在本例中)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3269790|其次，您不能实例化T，因为Java使用类型擦除实现泛型。几乎所有的通用信息都会在编译时被擦除。|3269791|基本上，你不能这样做：|3269792|T+member+=+new+T();|code-block|syntax|javascript|3269793|这里有一个关于generics的很好的教程。|3269794|entityMap|0|LINK|mutability|MUTABLE|url|http://www.angelikalanger.com/GenericsFAQ/JavaGenericsFAQ.html^0|M|1|0|9|1|0|0|0|7|8|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|11|8|@$9|12|A|13|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|14|8|@]|D|@]|E|$]]|$1|J|3|K|5|L|7|15|8|@]|D|@]|E|$M|N]]|$1|O|3|P|5|6|7|16|8|@]|D|@$9|17|A|18|1|19]]|E|$]]|$1|Q|3|-4|5|6|7|1A|8|@]|D|@]|E|$]]]|R|$S|$5|T|U|V|E|$W|X]]]]

First of all, you can't access the type parameter <code>T</code> in the static main method, only on non-static class members (in this case).

Second, you can't instantiate <code>T</code> because Java implements generics with Type Erasure. Almost all the generic information is erased at compile time.

Basically, you can't do this:

<pre><code>T member = new T();
</code></pre>

Here's a nice tutorial on <a href="http://www.angelikalanger.com/GenericsFAQ/JavaGenericsFAQ.html" rel="nofollow noreferrer">generics</a>.

blocks|key|311613|text|您需要静态地获取类型信息。试试这个：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|311614|public+class+Abc<T>+{
++++private+Class<T>+clazz;

++++public+Abc(Class<T>+clazz)+{
++++++++this.clazz+=+clazz;
++++}

++++public+T+getInstanceOfT()
++++++++++++throws+throws+InstantiationException,
+++++++++++++++++IllegalAccessException,
+++++++++++++++++IllegalArgumentException,
+++++++++++++++++InvocationTargetException,
+++++++++++++++++NoSuchMethodException,
+++++++++++++++++SecurityException+{
++++++++return+clazz.getDeclaredConstructor().newInstance();
++++}
}|code-block|syntax|javascript|311615|这样使用它：|311616|++++++++Abc<String>+abc+=+new+Abc<String>(String.class);
++++++++abc.getInstanceOfT();|311617|根据您的需要，您可能希望改用Class<?+extends+T>。|offset|length|style|CODE|311618|entityMap^0|0|0|0|0|E|I|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|W|8|@$M|X|N|Y|O|P]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

You need to get the type information statically. Try this:

<pre><code>public class Abc&lt;T&gt; {
 private Class&lt;T&gt; clazz;

 public Abc(Class&lt;T&gt; clazz) {
 this.clazz = clazz;
 }

 public T getInstanceOfT()
 throws throws InstantiationException,
 IllegalAccessException,
 IllegalArgumentException,
 InvocationTargetException,
 NoSuchMethodException,
 SecurityException {
 return clazz.getDeclaredConstructor().newInstance();
 }
}
</code></pre>

Use it as such:

<pre><code> Abc&lt;String&gt; abc = new Abc&lt;String&gt;(String.class);
 abc.getInstanceOfT();
</code></pre>

Depending on your needs, you may want to use <code>Class&lt;? extends T&gt;</code> instead.

blocks|key|311631|text|public+class+Abc<T>+{
++++public+T+getInstanceOfT(Class<T>+aClass)+{
+++++++return+aClass.newInstance();
++++}
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|311632|您必须添加异常处理。|unstyled|311633|您必须在运行时传递实际的类型，因为它在编译后不是字节码的一部分，所以如果不显式提供它，就无法知道它。|311634|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|L|8|@]|9|@]|A|$]]|$1|G|3|H|5|F|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|F|7|N|8|@]|9|@]|A|$]]]|J|$]]

<pre><code>public class Abc&lt;T&gt; {
 public T getInstanceOfT(Class&lt;T&gt; aClass) {
 return aClass.newInstance();
 }
}
</code></pre>

You'll have to add exception handling.

You have to pass the actual type at runtime, since it is not part of the byte code after compilation, so there is no way to know it without explicitly providing it.

blocks|key|314585|text|我使用下面的方法实现了同样的方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|314586|public+class+Abc<T>
{
+++T+myvar;

++++public+T+getInstance(Class<T>+clazz)+throws+InstantiationException,+IllegalAccessException
++++{
++++++++return+clazz.newInstance();
++++}
}|code-block|syntax|javascript|314587|我正在努力寻找一种更好的方法来实现同样的目标。|314588|有没有可能？|314589|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I was implementing the same using the following approach.

<pre><code>public class Abc&lt;T&gt;
{
 T myvar;

 public T getInstance(Class&lt;T&gt; clazz) throws InstantiationException, IllegalAccessException
 {
 return clazz.newInstance();
 }
}
</code></pre>

I was trying to find a better way to achieve the same. 

Isn't it possible?

blocks|key|316702|text|让它工作的唯一方法是使用。而这在Java中是不受支持的(还没有？它是为Java+7计划的，但被推迟了)。例如，在C#中，假设T有一个默认的构造函数，它是受支持的。您甚至可以通过typeof(T)获取运行时类型，通过Type.GetConstructor()获取构造函数。我不做C#，所以语法可能无效，但它大致如下所示：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|316703|public+class+Foo<T>+where+T:new()+{
++++public+void+foo()+{
++++++++T+t+=+new+T();
++++}
}|code-block|syntax|javascript|316704|在Java语言中，最好的“变通办法”是传递一个Class<T>作为方法参数，而不是像前面已经指出的那样。|316705|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/58918ffs.aspx|1|http://msdn.microsoft.com/en-us/library/system.type.aspx^0|1Q|1|2G|9|2Z|L|2G|9|0|2Z|L|1|0|0|N|8|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]|$9|Z|A|10|B|C]|$9|11|A|12|B|C]]|D|@$9|13|A|14|1|15]|$9|16|A|17|1|18]]|E|$]]|$1|F|3|G|5|H|7|19|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1A|8|@$9|1B|A|1C|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|1D|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]|U|$5|P|Q|R|E|$S|V]]]]

The only way to get it to work is to use <a href="http://en.wikipedia.org/wiki/Reification_%28computer_science%29" rel="noreferrer">Reified Generics</a>. And this is not supported in Java (yet? it was planned for Java 7, but has been postponed). In C# for example it is supported assuming that <code>T</code> has a default constructor. You can even get the runtime type by <a href="http://msdn.microsoft.com/en-us/library/58918ffs.aspx" rel="noreferrer"><code>typeof(T)</code></a> and get the constructors by <a href="http://msdn.microsoft.com/en-us/library/system.type.aspx" rel="noreferrer"><code>Type.GetConstructor()</code></a>. I don't do C# so the syntax may be invalid, but it roughly look like this:

<pre><code>public class Foo&lt;T&gt; where T:new() {
 public void foo() {
 T t = new T();
 }
}
</code></pre>

The best "workaround" for this in Java is to pass a <code>Class&lt;T&gt;</code> as method argument instead as several answers already pointed out.

blocks|key|316709|text|类型擦除解决方法|type|unstyled|depth|inlineStyleRanges|entityRanges|data|316710|受@martin's+answer的启发，我写了一个帮助器类，它允许我解决类型擦除问题。使用这个类(和一个丑陋的小把戏)，我能够在模板类型之外创建一个新的实例：|offset|length|316711|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();
++++}
}|code-block|syntax|javascript|316712|这里丑陋的技巧是将类设为abstract，这样类的用户就会被强制子类型。在这里，我通过在调用构造函数后附加{}来继承它。这定义了一个新的匿名类并创建了它的一个实例。|style|CODE|316713|一旦泛型类使用具体的模板类型子类型化，我就能够检索模板类型。|316714|316715|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+);
++++++++}
++++}
}|316716|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/2434041/instantiating-generics-type-in-java/2434094#2434094^0|0|1|G|0|0|0|C|8|1H|2|0|0|0|0^^$0|@$1|2|3|4|5|6|7|11|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|12|8|@]|9|@$D|13|E|14|1|15]]|A|$]]|$1|F|3|G|5|H|7|16|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|17|8|@$D|18|E|19|M|N]|$D|1A|E|1B|M|N]]|9|@]|A|$]]|$1|O|3|P|5|6|7|1C|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|1D|8|@]|9|@]|A|$]]|$1|R|3|S|5|H|7|1E|8|@]|9|@]|A|$I|J]]|$1|T|3|-4|5|6|7|1F|8|@]|9|@]|A|$]]]|U|$V|$5|W|X|Y|A|$Z|10]]]]

<h3>Type Erasure Workaround</h3>

Inspired by <a href="https://stackoverflow.com/questions/2434041/instantiating-generics-type-in-java/2434094#2434094">@martin's answer</a>, I wrote a helper class that allows me to workaround the type erasure problem. Using this class (and a little ugly trick) I'm able to create a new instance out of a template type:

<pre><code>public abstract class C_TestClass&lt;T &gt; {
 T createTemplateInstance() {
 return C_GenericsHelper.createTemplateInstance( this, 0 );
 }

 public static void main( String[] args ) {
 ArrayList&lt;String &gt; list = 
 new C_TestClass&lt;ArrayList&lt;String &gt; &gt;(){}.createTemplateInstance();
 }
}
</code></pre>

The ugly trick here is to make the class <code>abstract</code> so the user of the class is forced to subtype it. Here I'm subclassing it by appending <code>{}</code> after the call to the constructor. This defines a new anonymous class and creates an instance of it.

Once the generic class is subtyped with concrete template types, I'm able to retrieve the template types.

<hr>

<pre><code>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 &lt;T&gt; T createTemplateInstance( Object object, int index ) {
 ParameterizedType superClass = 
 (ParameterizedType )object.getClass().getGenericSuperclass();
 Type type = superClass.getActualTypeArguments()[ index ];
 Class&lt;T &gt; instanceType;
 if( type instanceof ParameterizedType ) {
 instanceType = (Class&lt;T &gt; )( (ParameterizedType )type ).getRawType();
 }
 else {
 instanceType = (Class&lt;T &gt; )type;
 }
 try {
 return instanceType.newInstance();
 }
 catch( Exception e ) {
 throw new RuntimeException( e );
 }
 }
}
</code></pre>

blocks|key|313619|text|当你真的必须这样做时，有一些老生常谈的方法可以绕过它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|313620|下面是一个我认为非常有用的转换方法的示例；它提供了一种确定泛型的具体类的方法。|313621|此方法接受对象集合作为输入，并返回一个数组，其中每个元素都是对输入集合中的每个对象调用字段getter的结果。例如，假设您有一个List<People>，并且您想要一个包含每个人的姓氏的String[]。|offset|length|style|CODE|313622|getter返回的字段值的类型由通用E指定，我需要实例化一个E[]类型的数组来存储返回值。|313623|该方法本身有点难看，但使用它编写的代码可以干净得多。|313624|请注意，只有在输入参数中的某个位置存在类型与返回类型匹配的对象时，此技术才有效，并且您可以确定地找出它。如果输入参数(或它们的子对象)的具体类不能告诉您任何有关泛型的信息，那么这种技术将不起作用。|313625|public+<E>+E[]+array+(Collection+c)+{
++++if+(c+==+null)+return+null;
++++if+(c.isEmpty())+return+(E[])+EMPTY_OBJECT_ARRAY;
++++final+List<E>+collect+=+(List<E>)+CollectionUtils.collect(c,+this);
++++final+Class<E>+elementType+=+(Class<E>)+ReflectionUtil.getterType(c.iterator().next(),+field);
++++return+collect.toArray((E[])+Array.newInstance(elementType,+collect.size()));
}|code-block|syntax|javascript|313626|完整代码在这里：https://github.com/cobbzilla/cobbzilla-utils/blob/master/src/main/java/org/cobbzilla/util/collection/FieldTransformer.java#L28|313627|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/cobbzilla/cobbzilla-utils/blob/master/src/main/java/org/cobbzilla/util/collection/FieldTransformer.java#L28^0|0|0|1S|C|2L|8|0|I|1|U|3|0|0|0|0|8|3I|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|15|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|16|8|@$F|17|G|18|H|I]|$F|19|G|1A|H|I]]|9|@]|A|$]]|$1|J|3|K|5|6|7|1B|8|@$F|1C|G|1D|H|I]|$F|1E|G|1F|H|I]]|9|@]|A|$]]|$1|L|3|M|5|6|7|1G|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|1H|8|@]|9|@]|A|$]]|$1|P|3|Q|5|R|7|1I|8|@]|9|@]|A|$S|T]]|$1|U|3|V|5|6|7|1J|8|@]|9|@$F|1K|G|1L|1|1M]]|A|$]]|$1|W|3|-4|5|6|7|1N|8|@]|9|@]|A|$]]]|X|$Y|$5|Z|10|11|A|$12|13]]]]

There are hacky ways around this when you really have to do it.

Here's an example of a transform method that I find very useful; and provides one way to determine the concrete class of a generic.

This method accepts a collection of objects as input, and returns an array where each element is the result of calling a field getter on each object in the input collection. For example, say you have a <code>List&lt;People&gt;</code> and you want a <code>String[]</code> containing everyone's last name.

The type of the field value returned by the getter is specified by the generic <code>E</code>, and I need to instantiate an array of type <code>E[]</code> to store the return value.

The method itself is a bit ugly, but the code you write that uses it can be so much cleaner.

Note that this technique only works when somewhere in the input arguments there is an object whose type matches the return type, and you can deterministically figure it out. If the concrete classes of your input parameters (or their sub-objects) can tell you nothing about the generics, then this technique won't work. 

<pre><code>public &lt;E&gt; E[] array (Collection c) {
 if (c == null) return null;
 if (c.isEmpty()) return (E[]) EMPTY_OBJECT_ARRAY;
 final List&lt;E&gt; collect = (List&lt;E&gt;) CollectionUtils.collect(c, this);
 final Class&lt;E&gt; elementType = (Class&lt;E&gt;) ReflectionUtil.getterType(c.iterator().next(), field);
 return collect.toArray((E[]) Array.newInstance(elementType, collect.size()));
}
</code></pre>

Full code is here: <a href="https://github.com/cobbzilla/cobbzilla-utils/blob/master/src/main/java/org/cobbzilla/util/collection/FieldTransformer.java#L28" rel="nofollow noreferrer">https://github.com/cobbzilla/cobbzilla-utils/blob/master/src/main/java/org/cobbzilla/util/collection/FieldTransformer.java#L28</a>

I would like to create an object of Generics Type in java. Please suggest how can I achieve the same.

Note: This may seem a trivial Generics Problem. But I bet.. it isn't. :)

suppose I have the class declaration as:

<pre><code>public class Abc&lt;T&gt; {
 public T getInstanceOfT() {
 // I want to create an instance of T and return the same.
 }
}
</code></pre>

Instantiating generics type in java

编译器

Java

我想在java中创建一个泛型类型的对象。请建议我如何实现同样的目标。注意:这可能看起来是一个微不足道的泛型问题。但我敢打赌..。不是。:)假设我有如下的类声明：public class Abc<T> { public T getInstanceOfT() { // I want to create a...

问在java中实例化泛型类型
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在java中实例化泛型类型EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在java中实例化泛型类型
EN