blocks|key|940938|text|通配符用于放宽您可以使用的对象的类型限制。在本例中，您接受extends/implements+Command类型的所有内容。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|CODE|entityRanges|data|940939|entityMap^0|T|I|1C|7|0^^$0|@$1|2|3|4|5|6|7|I|8|@$9|J|A|K|B|C]|$9|L|A|M|B|D]]|E|@]|F|$]]|$1|G|3|-4|5|6|7|N|8|@]|E|@]|F|$]]]|H|$]]

<a href="https://docs.oracle.com/javase/tutorial/java/generics/upperBounded.html" rel="noreferrer">Upper-bounded</a> wildcards are used to relax the type-restriction of objects you can use. In this case you accept everything that extends/implements the <code>Command</code> type.

blocks|key|934172|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|934173|泛型类型?+extends+Command是怎么叫的，比如它有名字吗？|blockquote|offset|length|style|CODE|934174|934175|934176|这些被称为通用wildcards。|934177|934178|这个类型到底是什么？它是一个Command对象吗？|934179|934180|934181|它只用于在编译时检查变量赋值。在运行时，泛型是erased的，并解释为List+myVar+=+client.performAction(actionParams);|934182|934183|这是否意味着它只接受扩展Command的类？|934184|934185|934186|您只能指定List<Command>+myVar+=+client.performAction(actionParams);，它将接受任何Command类型的对象或command的子类。|934187|List<?+extends+Command>+myVar控制变量赋值。因此，您只能将以下泛型分配给myVar。假设SubCommand扩展了命令，则以下赋值均有效：|934188|myVar+=+new+ArrayList<SubCommand>
myVar+=+new+ArrayList<Command>|code-block|syntax|javascript|934189|当使用通配符泛型声明集合时，它也可以变成read-only。例如，myVar.add(new+SubCommand());将导致编译器错误。|934190|934191|我使用这种构造的优势是什么？|934192|934193|934194|最初，Java不包含泛型。它是在Java5.0中添加的，以允许Java集合的类型限制，如List、Set、Map等。|934195|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.oracle.com/javase/tutorial/extra/generics/wildcards.html|1|https://docs.oracle.com/javase/tutorial/java/generics/erasure.html|2|http://What%2520is%2520my%2520advantage%2520using%2520this%2520sort%2520of%2520construct?^0|0|4|H|0|0|0|7|9|0|0|0|E|7|0|0|0|Z|1C|N|6|1|0|0|C|7|0|0|0|5|1L|1X|7|0|0|T|1E|5|0|0|X|S|K|9|2|0|0|0|0|0|18|4|1D|3|1H|3|0^^$0|@$1|2|3|-4|4|5|6|1R|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|1S|7|@$D|1T|E|1U|F|G]]|8|@]|9|$]]|$1|H|3|-4|4|5|6|1V|7|@]|8|@]|9|$]]|$1|I|3|-4|4|5|6|1W|7|@]|8|@]|9|$]]|$1|J|3|K|4|5|6|1X|7|@]|8|@$D|1Y|E|1Z|1|20]]|9|$]]|$1|L|3|-4|4|5|6|21|7|@]|8|@]|9|$]]|$1|M|3|N|4|C|6|22|7|@$D|23|E|24|F|G]]|8|@]|9|$]]|$1|O|3|-4|4|5|6|25|7|@]|8|@]|9|$]]|$1|P|3|-4|4|5|6|26|7|@]|8|@]|9|$]]|$1|Q|3|R|4|5|6|27|7|@$D|28|E|29|F|G]]|8|@$D|2A|E|2B|1|2C]]|9|$]]|$1|S|3|-4|4|5|6|2D|7|@]|8|@]|9|$]]|$1|T|3|U|4|C|6|2E|7|@$D|2F|E|2G|F|G]]|8|@]|9|$]]|$1|V|3|-4|4|5|6|2H|7|@]|8|@]|9|$]]|$1|W|3|-4|4|5|6|2I|7|@]|8|@]|9|$]]|$1|X|3|Y|4|5|6|2J|7|@$D|2K|E|2L|F|G]|$D|2M|E|2N|F|G]]|8|@]|9|$]]|$1|Z|3|10|4|5|6|2O|7|@$D|2P|E|2Q|F|G]|$D|2R|E|2S|F|G]]|8|@]|9|$]]|$1|11|3|12|4|13|6|2T|7|@]|8|@]|9|$14|15]]|$1|16|3|17|4|5|6|2U|7|@$D|2V|E|2W|F|G]]|8|@$D|2X|E|2Y|1|2Z]]|9|$]]|$1|18|3|-4|4|5|6|30|7|@]|8|@]|9|$]]|$1|19|3|1A|4|C|6|31|7|@]|8|@]|9|$]]|$1|1B|3|-4|4|5|6|32|7|@]|8|@]|9|$]]|$1|1C|3|-4|4|5|6|33|7|@]|8|@]|9|$]]|$1|1D|3|1E|4|5|6|34|7|@$D|35|E|36|F|G]|$D|37|E|38|F|G]|$D|39|E|3A|F|G]]|8|@]|9|$]]|$1|1F|3|-4|4|5|6|3B|7|@]|8|@]|9|$]]]|1G|$1H|$4|1I|1J|1K|9|$1L|1M]]|1N|$4|1I|1J|1K|9|$1L|1O]]|1P|$4|1I|1J|1K|9|$1L|1Q]]]]

<blockquote>
 How is the generic type <code>? extends Command</code> called, like is there a
 name for it?
</blockquote>

These are called generic <a href="https://docs.oracle.com/javase/tutorial/extra/generics/wildcards.html" rel="nofollow noreferrer">wildcards</a>. 

<blockquote>
 What exactly is this type? Is it a <code>Command</code> object?
</blockquote>

It's only used to check variable assignments at compile time. At runtime generics are <a href="https://docs.oracle.com/javase/tutorial/java/generics/erasure.html" rel="nofollow noreferrer">erased</a> and interpreted as <code>List myVar = client.performAction(actionParams);</code>

<blockquote>
 Does this mean that it only accepts classes extending <code>Command</code>? 
</blockquote>

You could only say <code>List&lt;Command&gt; myVar = client.performAction(actionParams);</code> and it would accept any object that is type of <code>Command</code> or a subclass of command.

<code>List&lt;? extends Command&gt; myVar</code> controls the variable assignment. So you could assign only the following generics to <code>myVar</code>. The following assignments are all valid, assuming that SubCommand extends Command:

<pre><code>myVar = new ArrayList&lt;SubCommand&gt;
myVar = new ArrayList&lt;Command&gt;
</code></pre>

When declaring collection with wildcard generic, it also can become <a href="http://What%20is%20my%20advantage%20using%20this%20sort%20of%20construct?" rel="nofollow noreferrer">read-only</a>. For example <code>myVar.add(new SubCommand());</code> will result a compiler error.

<blockquote>
 What is my advantage using this sort of construct?
</blockquote>

Originally Java did not include generics. It was added in Java 5.0 to allow type restriction of Java collections, like <code>List</code>, <code>Set</code>, <code>Map</code>, etc.

blocks|key|2994760|text|既然你同时问了很多问题，让我来总结一下：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2994761|当你实现数据结构，容器或算法，你想在不同的对象上使用而不必重写整个代码时，|2994762|泛型是至关重要的。如果我记得正确的泛型，在Java5.0中引入泛型之前，你仍然可以创建包含Object对象的灵活的数据结构，但你必须cast到instanceOf，并在代码中的许多地方使用instanceOf。因此引入了泛型来缓解这个问题并简化代码。|unordered-list-item|offset|length|style|CODE|2994763|正如NiVeR已经说过的，?是一个通配符运算符，List<?+extends+Command>会将List限制为包含扩展或实现的对象类或接口<+Command+>e118List>，以强制对对象代码进行约束|BOLD|2994764|2994765|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/users/1383240/niver^0|0|0|19|6|1U|4|1Z|A|2M|A|0|D|1|O|N|1D|4|20|7|1M|C|2|5|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Y|8|@$G|Z|H|10|I|J]|$G|11|H|12|I|J]|$G|13|H|14|I|J]|$G|15|H|16|I|J]]|9|@]|A|$]]|$1|K|3|L|5|F|7|17|8|@$G|18|H|19|I|J]|$G|1A|H|1B|I|J]|$G|1C|H|1D|I|J]|$G|1E|H|1F|I|J]|$G|1G|H|1H|I|M]]|9|@$G|1I|H|1J|1|1K]]|A|$]]|$1|N|3|-4|5|6|7|1L|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|1M|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]]]

Since you have asked many questions at once, let me recapitulate:

<ul>
<li>Generics are vital when you implement data structures, containers or algorithm that you want to use on different objects without having to rewrite the whole code</li>
<li>If I remember correctly generic where introduced in Java 5.0, 
before having generics in Java you could still create flexible data structure containing <code>Object</code> objects but you would have to <code>cast</code> to final type and use <code>instanceOf</code> in a lot of places in your code. Generics were thus introduced to ease this problem and to simplify the code.</li>
<li>As it has already being said by <a href="https://stackoverflow.com/users/1383240/niver">NiVeR</a>, <code>?</code> is a wildcard operator and <code>List&lt;? extends Command&gt;</code> would restrict the <code>List</code> to contain objects that extends or implements the class or the interface <code>Command</code> to enforce constraints on the object interface. </li>
</ul>

blocks|key|2994817|text|List<?+extends+Command>被称为上限通配符(许多答案已经解决了这个问题)。一般来说，没有人会这样声明他或她的列表；这主要用于方法中(更常见的是在静态方法中)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2994818|List<?+extends+Command>是指包含一种特定类型的Command+(即，一个特定的子类)的列表。因为它是一个未知子类类型，所以在编译时，您将无法添加任何内容。您的集成开发环境可能会将add方法解析为add(null+e)。|2994819|List<Command>，虽然看起来很相似，但它指的是一个包含任何内容的列表，只要它是一个Command+(或从Command派生的子类)。|2994820|示例：|2994821|List<?+extends+Command>+commands+=+new+ArrayList<FooCommand>();
commands.add(new+FooCommand());+//+Not+allowed+at+compile+time

List<Command>+commands+=+new+ArrayList<>();
commands.add(new+FooCommand());
commands.add(new+BarCommand());|code-block|syntax|javascript|2994822|使用时的示例：|2994823|public+static+void+doSomethingToCommands(List<?+extends+Command>+commands)+{
++++commands.forEach(this::doSomething);
}

List<FooCommand>+fooCommands+=+getFooCommands();
doSomethingToComamnds(fooCommands);+//+Allowed

List<Command>+commands+=+getRandomCommands();
doSomethingToComamnds(commands);+//+Not+allowed.|2994824|entityMap^0|0|N|0|0|N|Y|7|2S|3|30|B|0|0|D|1A|7|1L|7|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Z|8|@$9|10|A|11|B|C]|$9|12|A|13|B|C]|$9|14|A|15|B|C]|$9|16|A|17|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|18|8|@$9|19|A|1A|B|C]|$9|1B|A|1C|B|C]|$9|1D|A|1E|B|C]]|D|@]|E|$]]|$1|J|3|K|5|6|7|1F|8|@]|D|@]|E|$]]|$1|L|3|M|5|N|7|1G|8|@]|D|@]|E|$O|P]]|$1|Q|3|R|5|6|7|1H|8|@]|D|@]|E|$]]|$1|S|3|T|5|N|7|1I|8|@]|D|@]|E|$O|P]]|$1|U|3|-4|5|6|7|1J|8|@]|D|@]|E|$]]]|V|$]]

<code>List&lt;? extends Command&gt;</code> is called upper-bound wildcard (which many answers had already addressed this). In general, no one would declare his or her list like this; this is mainly used in methods (more commonly, in static methods).

<code>List&lt;? extends Command&gt;</code> refers to a list that holds one specific type of <code>Command</code> (i.e. one particular subclass). Since it's an unknown subclass type, at compile time, you will not be able to add anything. Your IDE will probably resolve <code>add</code> method to <code>add(null e)</code>.

<code>List&lt;Command&gt;</code>, though seemingly similar, refers to a list that holds anything, as long it is a <code>Command</code> (or subclassed from <code>Command</code>).

Example:

<pre><code>List&lt;? extends Command&gt; commands = new ArrayList&lt;FooCommand&gt;();
commands.add(new FooCommand()); // Not allowed at compile time

List&lt;Command&gt; commands = new ArrayList&lt;&gt;();
commands.add(new FooCommand());
commands.add(new BarCommand());
</code></pre>

Example of when it is used:

<pre><code>public static void doSomethingToCommands(List&lt;? extends Command&gt; commands) {
 commands.forEach(this::doSomething);
}

List&lt;FooCommand&gt; fooCommands = getFooCommands();
doSomethingToComamnds(fooCommands); // Allowed

List&lt;Command&gt; commands = getRandomCommands();
doSomethingToComamnds(commands); // Not allowed.
</code></pre>

blocks|key|2994865|text|关于List<?+extends+Command>的重要一点是它是一种抽象类型。您不能编写new+List<?+extends++Command>()并期望创建某些内容。有两个原因。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2994866|2994867|List是一个接口，具有ArrayList、LinkedList等具体实现。|unordered-list-item|2994868|类型参数中的通配符，这意味着“这可以是Command的子类型的任何类型，包括Command本身”。|2994869|2994870|这意味着List<?+extends+Command>类型的变量可以引用这些具体类型中的任何一个对象|2994871|2994872|ArrayList<Command>|2994873|LinkedList<SpecialCommand>|2994874|CopyOnWriteArrayList<ImportantCommand>|2994875|2994876|还有许多其他的组合。当然，假设SpecialCommand和ImportantCommand是Command的子类型。|2994877|当您创建该变量将要引用的对象时，您需要明确说明它是什么具体类型。例如|2994878|List<?+extends+Command>+myCommandList+=+new+ArrayList<SpecialCommand>();|code-block|syntax|javascript|2994879|完成此操作后，当然可以在myCommandList上调用一些常用的List方法，例如|2994880|Command+firstCommand+=+myCommandList.get(0);|2994881|这很好，因为我们知道无论列表中的对象是什么，它们都是某种类型的Command。但你不能像这样做|2994882|SpecialCommand+mySpecialCommand+=+new+SpecialCommand();
myCommandList.add(mySpecialCommand);|2994883|因为编译器无法知道您是否将正确类型的对象添加到列表中。在这一点上，myCommandList同样可以是LinkedList<ImportantCommand>或类似的，编译器需要防止向其添加SpecialCommand。|2994884|这意味着您应该仅在以下情况下使用List<?+extends+Command>类型|2994885|2994886|你不关心它是什么类型的列表(ArrayList，LinkedList或whatever)|2994887|you不关心列表中的Command是什么类型，你不会想要向列表中添加任何东西。|2994888|2994889|这意味着您通常不会将其用于局部变量或字段。它更有可能是一个方法参数，其中传入的内容可能是LinkedList<ImportantCommand>或其他什么；但是您在该方法中要做的就是从列表中取出对象，并对它们执行Command类型操作。|2994890|从Java5开始，Java中就包含了泛型，包括通配符。|2994891|entityMap^0|2|N|19|U|0|0|0|4|C|9|M|A|0|J|7|12|7|0|0|4|N|0|0|0|I|0|0|Q|0|0|12|0|0|F|E|U|G|1B|7|0|0|0|C|D|X|4|0|0|V|7|0|0|X|D|1F|S|2N|E|0|G|N|0|0|E|9|O|A|0|A|7|0|0|18|S|2Y|7|0|0^^$0|@$1|2|3|4|5|6|7|1T|8|@$9|1U|A|1V|B|C]|$9|1W|A|1X|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|1Y|8|@]|D|@]|E|$]]|$1|G|3|H|5|I|7|1Z|8|@$9|20|A|21|B|C]|$9|22|A|23|B|C]|$9|24|A|25|B|C]]|D|@]|E|$]]|$1|J|3|K|5|I|7|26|8|@$9|27|A|28|B|C]|$9|29|A|2A|B|C]]|D|@]|E|$]]|$1|L|3|-4|5|6|7|2B|8|@]|D|@]|E|$]]|$1|M|3|N|5|6|7|2C|8|@$9|2D|A|2E|B|C]]|D|@]|E|$]]|$1|O|3|-4|5|6|7|2F|8|@]|D|@]|E|$]]|$1|P|3|Q|5|I|7|2G|8|@$9|2H|A|2I|B|C]]|D|@]|E|$]]|$1|R|3|S|5|I|7|2J|8|@$9|2K|A|2L|B|C]]|D|@]|E|$]]|$1|T|3|U|5|I|7|2M|8|@$9|2N|A|2O|B|C]]|D|@]|E|$]]|$1|V|3|-4|5|6|7|2P|8|@]|D|@]|E|$]]|$1|W|3|X|5|6|7|2Q|8|@$9|2R|A|2S|B|C]|$9|2T|A|2U|B|C]|$9|2V|A|2W|B|C]]|D|@]|E|$]]|$1|Y|3|Z|5|6|7|2X|8|@]|D|@]|E|$]]|$1|10|3|11|5|12|7|2Y|8|@]|D|@]|E|$13|14]]|$1|15|3|16|5|6|7|2Z|8|@$9|30|A|31|B|C]|$9|32|A|33|B|C]]|D|@]|E|$]]|$1|17|3|18|5|12|7|34|8|@]|D|@]|E|$13|14]]|$1|19|3|1A|5|6|7|35|8|@$9|36|A|37|B|C]]|D|@]|E|$]]|$1|1B|3|1C|5|12|7|38|8|@]|D|@]|E|$13|14]]|$1|1D|3|1E|5|6|7|39|8|@$9|3A|A|3B|B|C]|$9|3C|A|3D|B|C]|$9|3E|A|3F|B|C]]|D|@]|E|$]]|$1|1F|3|1G|5|6|7|3G|8|@$9|3H|A|3I|B|C]]|D|@]|E|$]]|$1|1H|3|-4|5|6|7|3J|8|@]|D|@]|E|$]]|$1|1I|3|1J|5|I|7|3K|8|@$9|3L|A|3M|B|C]|$9|3N|A|3O|B|C]]|D|@]|E|$]]|$1|1K|3|1L|5|I|7|3P|8|@$9|3Q|A|3R|B|C]]|D|@]|E|$]]|$1|1M|3|-4|5|6|7|3S|8|@]|D|@]|E|$]]|$1|1N|3|1O|5|6|7|3T|8|@$9|3U|A|3V|B|C]|$9|3W|A|3X|B|C]]|D|@]|E|$]]|$1|1P|3|1Q|5|6|7|3Y|8|@]|D|@]|E|$]]|$1|1R|3|-4|5|6|7|3Z|8|@]|D|@]|E|$]]]|1S|$]]

The important point about <code>List&lt;? extends Command&gt;</code> is that it's an abstract type. You can't write <code>new List&lt;? extends Command&gt;()</code> and expect something to get created. There are two reasons. 

<ul>
<li><code>List</code> is an interface, with concrete implementations such as <code>ArrayList</code>, <code>LinkedList</code> and others.</li>
<li>The wildcard in the type parameter, which means "this could be any type that's a subtype of <code>Command</code>, including <code>Command</code> itself".</li>
</ul>

That means that a variable of type <code>List&lt;? extends Command&gt;</code> can reference an object of any of these concrete types

<ul>
<li><code>ArrayList&lt;Command&gt;</code></li>
<li><code>LinkedList&lt;SpecialCommand&gt;</code></li>
<li><code>CopyOnWriteArrayList&lt;ImportantCommand&gt;</code></li>
</ul>

and numerous other combinations. Assuming of course that <code>SpecialCommand</code> and <code>ImportantCommand</code> are subtypes of <code>Command</code>.

When you create an object that that variable is going to refer to, you need to be explicit about what concrete type it is. For example

<pre><code>List&lt;? extends Command&gt; myCommandList = new ArrayList&lt;SpecialCommand&gt;();
</code></pre>

Once you've done that, of course, you can call some of the usual <code>List</code> methods on <code>myCommandList</code>, such as

<pre><code>Command firstCommand = myCommandList.get(0);
</code></pre>

which is fine, because we know that whatever objects are in the list, they'll all be some type of <code>Command</code>. But you can't do things like

<pre><code>SpecialCommand mySpecialCommand = new SpecialCommand();
myCommandList.add(mySpecialCommand);
</code></pre>

because the compiler has no way of knowing that you're adding the right kind of object to the list. At this point, <code>myCommandList</code> could equally be a <code>LinkedList&lt;ImportantCommand&gt;</code>, or similar, and adding a <code>SpecialCommand</code> to it needs to be prevented by the compiler.

That means you should only use the type <code>List&lt;? extends Command&gt;</code> if you have a variable where

<ul>
<li>you don't care what kind of list it is (<code>ArrayList</code>, <code>LinkedList</code> or whatever)</li>
<li>you don't care what kind of <code>Command</code> is in the list</li>
<li>you're not going to be trying to add anything to the list.</li>
</ul>

That means you won't usually use it for a local variable or a field. It's more likely to be a method parameter, where the things passed in might be <code>LinkedList&lt;ImportantCommand&gt;</code> or whatever else; but all you'll be doing in that method is getting objects out of the list, and doing <code>Command</code> type operations on them.

Generics have been in Java since Java 5, including wildcards.

I am having trouble interpreting/understanding the generic type of a Java List:

<pre><code>List&lt;? extends Command&gt; myVar = client.performAction(actionParams);
</code></pre>

How is the generic type <code>? extends Command</code> called, like is there a name for it? What exactly is this type? Is it a <code>Command</code> object? Or does this mean that it only accepts classes extending <code>Command</code>? What is my advantage using this sort of construct? In what Java version was this type of construct integrated?

Generic list type with question mark

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我在解释/理解Java列表的泛型类型时遇到了问题：List<? extends Command> myVar = client.performAction(actionParams);泛型类型? extends Command是如何调用的，比如它有名字吗？这种类型到底是什么？它是一个Command对象吗？或者这是否意味...

问带问号的泛型列表类型
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问带问号的泛型列表类型EN