blocks|key|1325180|text|如果不知道要为特定的类使用哪种类型，泛型是一个很好的编程方法。在运行时，将根据类的输入设置泛型类类型。它主要用于编译时安全性。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1325181|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Generics is a good way to program if you don't know what type you're going to be using for a specific class. At runtime, the generic class type will be set based on the input to the class. It's mainly useful for compile time safety.

blocks|key|2619174|text|Java使用名为类型擦除的方法，因此在运行时无法获得有关类型的信息。但是，如果可以以某种方式传递类型信息，则可以使用Class.newInstance()方法创建任何类的实例(实际上，这是创建泛型数组的唯一方法)。|type|ordered-list-item|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2619175|编译时安全是泛型的主要目标。但是它们通常也可以用来编写更简洁的代码，否则这是不可能的。|2619176|关于详细的处理方法，我推荐优秀的书Java泛型和集合|unstyled|2619177|entityMap|0|LINK|mutability|MUTABLE|url|http://shop.oreilly.com/product/9780596527754.do^0|1M|J|0|0|H|9|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|6|7|V|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|W|8|@]|D|@$9|X|A|Y|1|Z]]|E|$]]|$1|K|3|-4|5|J|7|10|8|@]|D|@]|E|$]]]|L|$M|$5|N|O|P|E|$Q|R]]]]

<ol>
<li>Java Generics uses something called type erasure, so no information
about the type is available at runtime. It is, however, possible to
create an instance of any class using <code>Class.newInstance()</code> method if the type information can be passed somehow (in fact, this is the only way a generic array could be created)</li>
<li>Compile time safety is the primary goal of generics. But they can
 often be used to write more concise code as well, which would not have been possible otherwise</li>
</ol>

For a detailed treatment, I recommend the excellent book <a href="http://shop.oreilly.com/product/9780596527754.do" rel="nofollow noreferrer">Java Generics and Collections</a>

blocks|key|1325264|text|是否有任何与运行时保存的泛型类型有关的信息。？如果是，什么？|type|blockquote|depth|inlineStyleRanges|entityRanges|data|1325265|保存在编译类中的单个信息是从擦除后得到的原始对象/变量到源代码中用作泛型的特定类型的转换。|unstyled|1325266|但是它们仅仅依赖于声明的变量类型，而不是真正使用的泛型类型。|1325267|因此，在运行时，在实例化泛型类时，如果不传递类，则无法直接访问泛型信息。|1325268|如果不是，那么像google这样的库是如何在内部运行的(|1325269|你错了。|1325270|在Guice中，这个代码：|1325271|+Content+content+=+contentProvider.get();+++|code-block|syntax|javascript|1325272|将返回Content的实例，而不是泛型类型。看看文档：|offset|length|style|CODE|1325273|T+get()
提供T的一个实例。|BOLD|1325274|entityMap|0|LINK|mutability|MUTABLE|url|https://google.github.io/guice/api-docs/latest/javadoc/index.html?com/google/inject/Provider.html^0|0|0|0|0|0|0|0|0|3|7|O|2|0|0|0|7|0^^$0|@$1|2|3|4|5|6|7|1A|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|1B|8|@]|9|@]|A|$]]|$1|E|3|F|5|D|7|1C|8|@]|9|@]|A|$]]|$1|G|3|H|5|D|7|1D|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|1E|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|1F|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|1G|8|@]|9|@]|A|$]]|$1|O|3|P|5|Q|7|1H|8|@]|9|@]|A|$R|S]]|$1|T|3|U|5|D|7|1I|8|@$V|1J|W|1K|X|Y]]|9|@$V|1L|W|1M|1|1N]]|A|$]]|$1|Z|3|10|5|6|7|1O|8|@$V|1P|W|1Q|X|11]]|9|@]|A|$]]|$1|12|3|-4|5|D|7|1R|8|@]|9|@]|A|$]]]|13|$14|$5|15|16|17|A|$18|19]]]]

<blockquote>
Is there any information related to generic types which is preserved
at runtime as well. ? If yes, what ?.
</blockquote>
Single information preserved in the compiled class, are casts from raw objects/variables gotten after erasure to the specific types used as generic in the source code. 
But these rely just on the declared type of variable, not the real generic type used.
So, at runtime you cannot directly access to the generic information without workaround as passing a class when you instantiate a generic class.
<blockquote>
If no, than how does libraries like google guice operate internally (
</blockquote>
You are wrong. 
In Guice this code :
<pre><code> Content content = contentProvider.get(); 
</code></pre>
will return an instance of <code>Content</code>, not the generic type.
Look at the <a href="https://google.github.io/guice/api-docs/latest/javadoc/index.html?com/google/inject/Provider.html" rel="nofollow noreferrer">documentation</a> :
<blockquote>
T get()
Provides an instance of T.
</blockquote>

blocks|key|1325305|text|如果一个类扩展了一个泛型类或接口，并为参数提供了一个具体的类型，那么该类型可以通过Class.getGenericSuperclass()获得。该方法(在本例中)将返回包含实际参数化的ParameterizedType。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1325306|例如，如果您有：|1325307|class+BigIntegerList+extends+ArrayList<BigInteger>+{}|code-block|syntax|javascript|1325308|然后你就可以：|1325309|Class<BigIntegerList>+fooClass+=+BigIntegerList.class;
Type+superclass+=+fooClass.getGenericSuperclass();
if+(superclass+instanceof+ParameterizedType)+{
++ParameterizedType+parameterized+=+(ParameterizedType)+superclass;
++Type[]+parameterizations+=+parameterized.getActualTypeArguments();
++System.out.println(Arrays.toString(parameterizations));
++//+prints:+"[class+java.math.BigInteger]"
}|1325310|这确实被像Guice这样的反射密集型库所使用。另一个例子是Jackson的TypeReference，它可以让您以BigDecimal列表的形式读取JSON列表(例如)。|1325311|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html#getGenericSuperclass--|1|https://docs.oracle.com/javase/8/docs/api/java/lang/reflect/ParameterizedType.html|2|https://fasterxml.github.io/jackson-core/javadoc/2.7/com/fasterxml/jackson/core/type/TypeReference.html?is-external=true^0|15|S|2K|H|15|S|0|2K|H|1|0|0|0|0|0|11|D|11|D|2|0^^$0|@$1|2|3|4|5|6|7|14|8|@$9|15|A|16|B|C]|$9|17|A|18|B|C]]|D|@$9|19|A|1A|1|1B]|$9|1C|A|1D|1|1E]]|E|$]]|$1|F|3|G|5|6|7|1F|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|1G|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1H|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|1I|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|1J|8|@$9|1K|A|1L|B|C]]|D|@$9|1M|A|1N|1|1O]]|E|$]]|$1|S|3|-4|5|6|7|1P|8|@]|D|@]|E|$]]]|T|$U|$5|V|W|X|E|$Y|Z]]|10|$5|V|W|X|E|$Y|11]]|12|$5|V|W|X|E|$Y|13]]]]

If a class extends a generic class or interface and provides a concrete type for the parameter, then that type is available via <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html#getGenericSuperclass--" rel="nofollow noreferrer"><code>Class.getGenericSuperclass()</code></a>. That method will (in this case) return a <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/reflect/ParameterizedType.html" rel="nofollow noreferrer"><code>ParameterizedType</code></a> that will contain the actual parameterization.

For instance, if you have:

<pre><code>class BigIntegerList extends ArrayList&lt;BigInteger&gt; {}
</code></pre>

Then you can do:

<pre><code>Class&lt;BigIntegerList&gt; fooClass = BigIntegerList.class;
Type superclass = fooClass.getGenericSuperclass();
if (superclass instanceof ParameterizedType) {
 ParameterizedType parameterized = (ParameterizedType) superclass;
 Type[] parameterizations = parameterized.getActualTypeArguments();
 System.out.println(Arrays.toString(parameterizations));
 // prints: "[class java.math.BigInteger]"
}
</code></pre>

This is indeed used by reflection-heavy libraries such as Guice. Another example is Jackson's <a href="https://fasterxml.github.io/jackson-core/javadoc/2.7/com/fasterxml/jackson/core/type/TypeReference.html?is-external=true" rel="nofollow noreferrer"><code>TypeReference</code></a>, which can let you read a JSON list-of-things as list-of-BigDecimal (for instance).

blocks|key|2657086|text|泛型信息只持续到编译时，.In您的示例也可用，直到编译时为止。让我用一个例子来解释|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2657087|公开无效printObject(列表删除){|2657088|//这并不显示该列表在运行时保存此信息，即它将返回哪种类型的对象。就业en+=empt.get()；}|2657089|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

Generic information only persist till compile time .In your example as well it is available till compile time. Let me explain it with one example 

Public void printObject( list empt) {

// This don't shows that list keep this information at runtime that what type of object it will return .
Employment en =empt.get();
}

blocks|key|2657156|text|当然，支持类是泛型的信息。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2657157|换句话说:当您反编译ArrayList.class时，您会发现这个类允许一个泛型类型参数的提示。换句话说:类文件包含元信息。使用反射，可以在运行时检查此元信息。|offset|length|style|BOLD|2657158|但是，当您有另一个使用某些List<Integer>对象的类时--则在编译的类中找不到关于"list使用Integer“的信息--除非您使用一些特定的模式，例如，概述了这里。|CODE|2657159|因此，答案基本上是:对于几乎所有实际相关的用例，“泛型”只是编译时间。|2657160|示例：|2657161|public+class+GenericsExample<T>+{
++private+T+member;+++
++public+T+foo(T+bar)+{
+++++return+member;
++}
}|code-block|syntax|javascript|2657162|现在运行:+javap+-p+-c+GenericsExample|2657163|Compiled+from+"GenericsExample.java"
public+class+GenericsExample<T>+{
++private+T+member;

++public+GenericsExample();
++++Code:
+++++++0:+aload_0+++++++
+++++++1:+invokespecial+#1++++++++++++++++++//+Method+java/lang/Object."<init>":()V
+++++++4:+return++++++++

++public+T+foo(T);
++++Code:
+++++++0:+aload_0+++++++
+++++++1:+getfield++++++#2++++++++++++++++++//+Field+member:Ljava/lang/Object;
+++++++4:+areturn+++++++
}|2657164|如您所见，反编译器理解该类使用泛型类型T。有关更多细节，请参见这里或那里。|2657165|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/3403909/get-generic-type-of-class-at-runtime|1|https://stackoverflow.com/questions/28486081/java-bytecode-signatures|2|https://stackoverflow.com/questions/29375575/java-generics-type-erasure-byte-code^0|0|1M|1|0|D|D|2C|2|0|0|0|0|0|0|0|V|2|1|Y|2|2|0^^$0|@$1|2|3|4|5|6|7|1B|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1C|8|@$D|1D|E|1E|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|1F|8|@$D|1G|E|1H|F|J]]|9|@$D|1I|E|1J|1|1K]]|A|$]]|$1|K|3|L|5|6|7|1L|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|1M|8|@]|9|@]|A|$]]|$1|O|3|P|5|Q|7|1N|8|@]|9|@]|A|$R|S]]|$1|T|3|U|5|6|7|1O|8|@]|9|@]|A|$]]|$1|V|3|W|5|Q|7|1P|8|@]|9|@]|A|$R|S]]|$1|X|3|Y|5|6|7|1Q|8|@]|9|@$D|1R|E|1S|1|1T]|$D|1U|E|1V|1|1W]]|A|$]]|$1|Z|3|-4|5|6|7|1X|8|@]|9|@]|A|$]]]|10|$11|$5|12|13|14|A|$15|16]]|17|$5|12|13|14|A|$15|18]]|19|$5|12|13|14|A|$15|1A]]]]

Of course the information that a class is generic is supported. 

In other words: when you decompile ArrayList.class you will find hints about the fact that this class allows for one generic type parameter. In other words: class files contain meta information. And using reflection it is possible to inspect this meta information at runtime.

But when you have another class that uses some <code>List&lt;Integer&gt;</code> object - then you do not find information about that "list uses an Integer" in the compiled class - unless you use some specific patterns, as outlined <a href="https://stackoverflow.com/questions/3403909/get-generic-type-of-class-at-runtime">here</a> for example.

So the answer is basically: for almost all use cases of practical relevance, "generics" are compile time only. 

Example:

<pre><code>public class GenericsExample&lt;T&gt; {
 private T member; 
 public T foo(T bar) {
 return member;
 }
}
</code></pre>

Now run: javap -p -c GenericsExample 

<pre><code>Compiled from "GenericsExample.java"
public class GenericsExample&lt;T&gt; {
 private T member;

 public GenericsExample();
 Code:
 0: aload_0 
 1: invokespecial #1 // Method java/lang/Object."&lt;init&gt;":()V
 4: return 

 public T foo(T);
 Code:
 0: aload_0 
 1: getfield #2 // Field member:Ljava/lang/Object;
 4: areturn 
}
</code></pre>

As you can see the decompiler understands that the class uses that generic type T. For more details see <a href="https://stackoverflow.com/questions/28486081/java-bytecode-signatures">here</a> or <a href="https://stackoverflow.com/questions/29375575/java-generics-type-erasure-byte-code">there</a>.

Background

My understanding of Java generics is it being completely a compile time feature (mainly focusing on type safety checks). 
The type information for any generic class is lost at runtime (type erasure). 

Still, i see many frameworks seem to leverage the type information at runtime as well. For example, google guice <a href="https://google.github.io/guice/api-docs/latest/javadoc/index.html?com/google/inject/Provider.html" rel="nofollow noreferrer">Providers</a>. The guice provider can instantiate and provide new instances of it's generic type at runtime.

<pre><code>class Container
{
 @Inject 
 public Container(Provider&lt;Content&gt; contentProvider)
 {
 //This works at Runtime... but How ??? 
 //When type's are not even preserved at runtime, how does the Provider knows it has to instantiate an object of type 'Content' 
 Content content = contentProvider.get(); 
 }
}
</code></pre>

Question

<ol>
<li>Is there any information related to generic types which is preserved at runtime as well. ? If yes, what ?. If no, than how does libraries like google guice operate internally (Above example)</li>
<li>Is there more to generics than just compile time safety ? As in, is there any use-case (other than ensuring compile time safety) where one would get advantage using generics ? </li>
</ol>

Java Generics : Is any meta information about the generic type preserved at runtime as well?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

背景我对Java泛型的理解是，它完全是编译时特性(主要关注类型安全检查)。任何泛型类的类型信息在运行时丢失(类型擦除)。尽管如此，我仍然看到许多框架()似乎也可以在运行时利用类型信息。例如，google 。guice提供程序可以在运行时实例化并提供其泛型类型的新实例。class Container{     @Inje...

问Java :在运行时是否也保存了关于泛型类型的任何元信息？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java :在运行时是否也保存了关于泛型类型的任何元信息？EN