blocks|key|2904586|text|关于您的第一个问题，请考虑如下字段声明|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2904587|public+List<String>+parameterizedField;|code-block|syntax|javascript|2904588|与Class对象一样，JVM不维护表示List<String>类型的对象。因此，它需要创建一个表示该类型的新Type+(在本例中为ParameterizedType)对象并返回它(它还可能缓存它以供将来使用)。它将对以下对象执行相同的操作|offset|length|style|CODE|2904589|public+E+genericField;|2904590|在本例中创建一个TypeVariable对象。|2904591|为|2904592|public+String+regularTypeField;|2904593|但是，类型是已知的，JVM为String维护了一个Class对象，因此只需要返回该对象。|2904594|2904595|在第二种情况下，类型令牌hack|2904596|new+TypeToken<List<String>>()+{}|2904597|在内部创建表示List<String>的Type，否则由于类型擦除而无法直接检索该not。|2904598|resolveType调用检查您给它的类型，并根据TypeToken的类型参数解析它。|2904599|在您的示例中，调用的getGenericReturnType()将返回一个表示在List类中声明的类型变量的Type。由于您已经使用String参数化了List，因此resolveType()将返回String。它将您在类型标记中提供的类型参数绑定到在方法或字段中使用的相应类型变量。|2904600|你是否使用过|2904601|new+TypeToken<List<String>>()+{}.
++++resolveType(Iterator.class.getMethod("next").getGenericReturnType())|2904602|它将返回E，因为该类型变量与您在类型令牌中绑定的变量无关。|2904603|2904604|这两种情况下resolved的用法是不同的。|2904605|entityMap^0|0|0|1|5|J|C|1I|4|1T|H|0|0|8|C|0|0|0|E|6|P|5|0|0|0|0|7|C|K|4|0|0|B|P|9|0|A|M|14|4|1I|4|1U|6|24|4|2B|D|2R|6|0|0|0|4|1|0|0|0^^$0|@$1|2|3|4|5|6|7|1I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|1J|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|1K|8|@$I|1L|J|1M|K|L]|$I|1N|J|1O|K|L]|$I|1P|J|1Q|K|L]|$I|1R|J|1S|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|1T|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|1U|8|@$I|1V|J|1W|K|L]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1X|8|@]|9|@]|A|$]]|$1|S|3|T|5|D|7|1Y|8|@]|9|@]|A|$E|F]]|$1|U|3|V|5|6|7|1Z|8|@$I|20|J|21|K|L]|$I|22|J|23|K|L]]|9|@]|A|$]]|$1|W|3|-4|5|6|7|24|8|@]|9|@]|A|$]]|$1|X|3|Y|5|6|7|25|8|@]|9|@]|A|$]]|$1|Z|3|10|5|D|7|26|8|@]|9|@]|A|$E|F]]|$1|11|3|12|5|6|7|27|8|@$I|28|J|29|K|L]|$I|2A|J|2B|K|L]]|9|@]|A|$]]|$1|13|3|14|5|6|7|2C|8|@$I|2D|J|2E|K|L]|$I|2F|J|2G|K|L]]|9|@]|A|$]]|$1|15|3|16|5|6|7|2H|8|@$I|2I|J|2J|K|L]|$I|2K|J|2L|K|L]|$I|2M|J|2N|K|L]|$I|2O|J|2P|K|L]|$I|2Q|J|2R|K|L]|$I|2S|J|2T|K|L]|$I|2U|J|2V|K|L]]|9|@]|A|$]]|$1|17|3|18|5|6|7|2W|8|@]|9|@]|A|$]]|$1|19|3|1A|5|D|7|2X|8|@]|9|@]|A|$E|F]]|$1|1B|3|1C|5|6|7|2Y|8|@$I|2Z|J|30|K|L]]|9|@]|A|$]]|$1|1D|3|-4|5|6|7|31|8|@]|9|@]|A|$]]|$1|1E|3|1F|5|6|7|32|8|@]|9|@]|A|$]]|$1|1G|3|-4|5|6|7|33|8|@]|9|@]|A|$]]]|1H|$]]

Regarding your first question, consider a field declaration like

<pre><code>public List&lt;String&gt; parameterizedField;
</code></pre>

The JVM does not maintain an object representing the type <code>List&lt;String&gt;</code> (as it would a <code>Class</code> object). It therefore needs to create a new <code>Type</code> (<code>ParameterizedType</code> in this case) object representing that type and return it (it might also cache it for future use). It will do the same for 

<pre><code>public E genericField;
</code></pre>

creating a <code>TypeVariable</code> object in this case.

For 

<pre><code>public String regularTypeField;
</code></pre>

however, the type is known, the JVM maintains a <code>Class</code> object for <code>String</code> and therefore only needs to return that.

<hr>

In the second case, the type token hack

<pre><code>new TypeToken&lt;List&lt;String&gt;&gt;() {}
</code></pre>

internally creates a <code>Type</code> that represents <code>List&lt;String&gt;</code> which would otherwise not be possible to retrieve directly because of type erasure.

The <code>resolveType</code> call checks the <code>Type</code> you give it and resolves it based on the <code>TypeToken</code>'s type argument.

In your example, the <code>getGenericReturnType()</code> invoked will return a <code>Type</code> representing the type variable declared in the <code>List</code> class. Since you've parameterized <code>List</code> with <code>String</code>, <code>resolveType()</code> will return <code>String</code>. It binds the type argument you provided in the type token to its corresponding type variable used in methods or fields.

Had you used 

<pre><code>new TypeToken&lt;List&lt;String&gt;&gt;() {}.
 resolveType(Iterator.class.getMethod("next").getGenericReturnType())
</code></pre>

it would have returned <code>E</code> because that type variable is unrelated to the one you bound in the type token.

<hr>

The uses of resolved in both cases is different.

What does it mean to resolve a type in Java?

Here are some usage examples with my attempts at making sense of them:

From <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/reflect/Field.html#getGenericType--"><code>Field#getGenericType()</code></a>:

<blockquote>
 If the type of the underlying field is a type variable or a parameterized type, it is created. Otherwise, it is resolved.
</blockquote>

<ul>
<li>Type variables or parameterized types need to be created for this form of reflection to work because they can't be loaded, because they don't really "exist" at runtime?</li>
<li>So if something exists at runtime, it can be "resolved"? By the classloader?</li>
</ul>

From <a href="http://docs.guava-libraries.googlecode.com/git-history/v18.0/javadoc/com/google/common/reflect/TypeToken.html#resolveType(java.lang.reflect.Type)"><code>TypeToken#resolveType()</code></a>:

<blockquote>
 Resolves the given type against the type context represented by this type. For example:
</blockquote>

<pre><code>new TypeToken&lt;List&lt;String&gt;&gt;() {}.resolveType(
 List.class.getMethod("get", int.class).getGenericReturnType())
=&gt; String.class
</code></pre>

<ul>
<li>This I don't really get at all. Not sure what this code is doing.</li>
</ul>

What does it mean to resolve a type in Java?

在Java中解析一个类型意味着什么？下面是我尝试理解它们的一些用法示例：来自 的如果基础字段的类型是类型变量或参数化类型，则创建它。否则，它将被解决。要使这种形式的反射起作用，需要创建类型变量或参数化类型，因为它们不能被加载，因为它们在运行时并不真正“存在”？所以如果在运行时存在某些东西，它可以被“解决”吗？由clas...

问在Java中解析一个类型意味着什么？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Java中解析一个类型意味着什么？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Java中解析一个类型意味着什么？
EN