blocks|key|2033976|text|您的部分困惑可能源于这样一个事实:在这种情况下，让run成为一个通用方法是没有意义的。通常使用类型参数在两个参数类型和/或参数类型与返回类型之间创建关系。在您的示例中，run可以被声明为需要一个Object参数(一个没有声明的绑定的类型参数实际上将Object作为其绑定)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2033977|有一种情况我知道，您可以在单个参数类型中有效地使用类型参数:当您希望能够以不依赖于元素类型但确实需要将元素插入到集合中的方式操作集合时。例如，考虑一个假设的“反向列表”方法：|2033978|<T>+void+reverse(List<T>+list)
{
++++List<T>+reversed+=+new+ArrayList<T>();
++++for+(int+i+=+list.size();+i+>+0;+i--)+{
++++++++reversed.add(list.get(i+-+1));
++++}
++++list.clear();
++++list.addAll(reversed);
}|code-block|syntax|javascript|2033979|要以不需要类型参数(即接受List<?>参数)的方式编写它是很困难的。没有强制转换的唯一方法是这样做：|2033980|void+reverse2(List<?>+list)
{
++++reverse(list);++//+call+reverse+as+defined+above!
}|2033981|但同样，这并不适用于您讨论的示例。|2033982|因此，总结如下：|2033983|没有显式边界的类型参数实际上具有Object界。|2033984|方法可能需要类型参数(有或没有显式约束)有两个原因：|2033985|指定参数类型和/或返回类型之间的关系|unordered-list-item|2033986|捕获潜在的通配符作为类型参数，以允许不可能进行的操作(如reverse示例中所示)。|2033987|您讨论的示例方法：|2033988|public<T>++void+run+(T+obj+)|2033989|..。这两个都不做，所以类型参数是没有意义的。该方法可能与public+void+run(Object+obj)一样被声明。|2033990|entityMap^0|P|3|2C|3|2P|6|3G|6|0|0|0|D|7|0|0|0|0|G|6|0|0|0|S|7|0|0|0|T|R|0^^$0|@$1|2|3|4|5|6|7|1B|8|@$9|1C|A|1D|B|C]|$9|1E|A|1F|B|C]|$9|1G|A|1H|B|C]|$9|1I|A|1J|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1K|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|1L|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1M|8|@$9|1N|A|1O|B|C]]|D|@]|E|$]]|$1|O|3|P|5|J|7|1P|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|1Q|8|@]|D|@]|E|$]]|$1|S|3|T|5|6|7|1R|8|@]|D|@]|E|$]]|$1|U|3|V|5|6|7|1S|8|@$9|1T|A|1U|B|C]]|D|@]|E|$]]|$1|W|3|X|5|6|7|1V|8|@]|D|@]|E|$]]|$1|Y|3|Z|5|10|7|1W|8|@]|D|@]|E|$]]|$1|11|3|12|5|10|7|1X|8|@$9|1Y|A|1Z|B|C]]|D|@]|E|$]]|$1|13|3|14|5|6|7|20|8|@]|D|@]|E|$]]|$1|15|3|16|5|J|7|21|8|@]|D|@]|E|$K|L]]|$1|17|3|18|5|6|7|22|8|@$9|23|A|24|B|C]]|D|@]|E|$]]|$1|19|3|-4|5|6|7|25|8|@]|D|@]|E|$]]]|1A|$]]

Part of your confusion may stem from the fact that there is no point in having <code>run</code> be a generic method in this case. You normally use a type parameter to create a relationship between two parameter types and/or between parameter type and return type. In your example <code>run</code> could just as well have been declared as requiring an <code>Object</code> parameter (a type parameter without a declared bound effectively has <code>Object</code> as its bound).

There is one case I know of where you might usefully use a type parameter in a single parameter type: when you want to be able to manipulate a collection in a way that doesn't depend on the element type, but which does require inserting elements into the collection. Consider for example a hypothetical "reverse list" method:

<pre><code>&lt;T&gt; void reverse(List&lt;T&gt; list)
{
 List&lt;T&gt; reversed = new ArrayList&lt;T&gt;();
 for (int i = list.size(); i &gt; 0; i--) {
 reversed.add(list.get(i - 1));
 }
 list.clear();
 list.addAll(reversed);
}
</code></pre>

It would be difficult to write this in a way that didn't require a type parameter, i.e. that takes a <code>List&lt;?&gt;</code> parameter. The only way to do it without casts is to do:

<pre><code>void reverse2(List&lt;?&gt; list)
{
 reverse(list); // call reverse as defined above!
}
</code></pre>

But again, this doesn't apply in the example you discuss.

So in summary:

A type parameter without an explicit bound effectively has an <code>Object</code> bound.

There are two reasons why a method might need a type parameter (either with or without an explicit bound):

<ul>
<li>Specify a relationship between parameter types and/or return type</li>
<li>Capture a potential wildcard as a type parameter to allow operations that wouldn't otherwise be possible (as in the <code>reverse</code> example).</li>
</ul>

The example method you discussed:

<pre><code>public&lt;T&gt; void run (T obj )
</code></pre>

... does neither of these, and so the type parameter is pointless. The method might just as well have been declared as <code>public void run(Object obj)</code>.

blocks|key|623342|text|在这种情况下，函数也可以使用Object，但对您来说有意义的变体也等同于public+void+run(Number+obj)+{+...+}。例如，缺少绑定是有意义的，考虑返回类型提到T：public+<T>+List<T>+singletonList(T+obj)的情况。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|623343|entityMap^0|E|6|10|Z|2L|1|2N|13|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|G|$]]

While in this case the function could take <code>Object</code> just as well, the variant that makes sense to you is equivalent to <code>public void run(Number obj) { ... }</code> as well. For an example where lack of bound makes sense consider a case where the return type mentions <code>T</code>: <code>public &lt;T&gt; List&lt;T&gt; singletonList(T obj)</code>.

blocks|key|623357|text|这里唯一有意义的是，如果这是某种伪抽象或基类，它为行为提供了框架，让另一个程序员实现自己的逻辑，但也提供了默认的空操作。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|623358|它可以允许更好地设置泛型类型，例如：|623359|class+MySubClass+extends+JavaApplication14+{
++++public+<T>+void+run(T+obj){
++++++++new+ArrayList<T>().add(obj);
++++}
}|code-block|syntax|javascript|623360|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

The only thing makes sense here is if this was some kind of pseudo-abstract or base class, that provided framework for behaviour and let another coders implement their own logic, but also provided default null action.

It could allow for better generic type-setting, for example as:

<pre><code>class MySubClass extends JavaApplication14 {
 public &lt;T&gt; void run(T obj){
 new ArrayList&lt;T&gt;().add(obj);
 }
}
</code></pre>

blocks|key|2034012|text|它允许你避免任何的演员.|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|2034013|public+class+SomeClass+{
++++++void+doStuff();++++
}

public<T+extends+SomeClass>++void+run+(T+obj)+{
++++//can+call+doStuff+without+any+casting
++++obj.doStuff();
}

public<T>++void+run+(T)+{
++++//Here,+there's+no+clue+to+perform+the+implicit+cast.
++++obj.doStuff();++//won't+compile
}|code-block|syntax|javascript|2034014|entityMap^0|0|C|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

It allows you to avoid any cast.

<pre><code>public class SomeClass {
 void doStuff(); 
}

public&lt;T extends SomeClass&gt; void run (T obj) {
 //can call doStuff without any casting
 obj.doStuff();
}

public&lt;T&gt; void run (T) {
 //Here, there's no clue to perform the implicit cast.
 obj.doStuff(); //won't compile
}
</code></pre>

blocks|key|623368|text|一些理论|type|unstyled|depth|inlineStyleRanges|entityRanges|data|623369|有一些通用的方法。它们的主要目标是通用算法(接收和返回相同类型)。|623370|使用泛型的代码比非泛型代码有很多好处。|offset|length|style|BOLD|623371|消除铸型。|unordered-list-item|623372|编译时进行更强的类型检查。|623373|使程序员能够实现通用算法。|623374|小小的练习|623375|考虑以下代码：|623376|class+MyClass+{

++++public+void+method()+{}

++++public+static+void+main(String[]+args)+{
++++++++runFirst(new+MyClass());
++++++++runSecond(new+MyClass());
++++}

++++public+static+<T+extends+MyClass>+void+runFirst(T+obj)+{
++++++++obj.method();
++++}

++++public+static+<T>+void+runSecond(T+obj)+{
++++++++((MyClass)+obj).method();
++++}
}|code-block|syntax|javascript|623377|runFirst()方法允许我们避免对类及其所有子类进行强制转换。在runSecond()方法中，我们可以得到任何类型的参数(<T>，粗略地说，意思是<T+extends+Object>)。首先，我们必须转换为MyClass，然后调用它的方法。|CODE|623378|entityMap^0|0|0|5|8|0|0|0|0|0|0|0|0|A|Y|B|1R|3|23|I|2X|7|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]]|9|@]|A|$]]|$1|J|3|K|5|L|7|19|8|@]|9|@]|A|$]]|$1|M|3|N|5|L|7|1A|8|@]|9|@]|A|$]]|$1|O|3|P|5|L|7|1B|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1C|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|1D|8|@]|9|@]|A|$]]|$1|U|3|V|5|W|7|1E|8|@]|9|@]|A|$X|Y]]|$1|Z|3|10|5|6|7|1F|8|@$F|1G|G|1H|H|11]|$F|1I|G|1J|H|11]|$F|1K|G|1L|H|11]|$F|1M|G|1N|H|11]|$F|1O|G|1P|H|11]]|9|@]|A|$]]|$1|12|3|-4|5|6|7|1Q|8|@]|9|@]|A|$]]]|13|$]]

<h2>Some theory</h2>

There're generic methods. Their main goal is generic algorithms (receive and return same types).

Code that uses generics has many benefits over non-generic code:

<ul>
<li>Elimination of casts. </li>
<li>Stronger type checks at compile time. </li>
<li>Enabling programmers to implement generic algorithms.</li>
</ul>

<h2>A little practice</h2>

Consider the following code:

<pre><code>class MyClass {

 public void method() {}

 public static void main(String[] args) {
 runFirst(new MyClass());
 runSecond(new MyClass());
 }

 public static &lt;T extends MyClass&gt; void runFirst(T obj) {
 obj.method();
 }

 public static &lt;T&gt; void runSecond(T obj) {
 ((MyClass) obj).method();
 }
}
</code></pre>

The <code>runFirst()</code> method allows us to avoid cast to class and all its subclasses. In <code>runSecond()</code> method we can get any type of parameter (<code>&lt;T&gt;</code>, roughly speaking, means <code>&lt;T extends Object&gt;</code>). Firstly, we must cast to <code>MyClass</code> and then call its method.

blocks|key|625345|text|首先，我将从public+<T>+void+run(T+object)+{+...+}的含义开始。是的，当您使用这种代码时，您可能会使用任何对象作为运行参数。如果您想将这个函数的参数限制在一个特定的接口、类或它的子类上，您只需编写类似于NotGenericRun的代码，如下所示。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|625346|public+class+NotGenericRun+{

++++public+void+run(ArrayList<?>+list)+{
++++++++String+message+=+"Non+Generic+Run+List:+";
++++++++System.out.println(message.concat(list.toString()));
++++}

++++public+void+run(int+intValue)+{
++++++++String+message+=+"Non+Generic+Run+Int:+";
++++++++System.out.println(message.concat(String.valueOf(intValue)));
++++}

}|code-block|syntax|javascript|625347|在这里，我测试了GenericRun和NotGenericRun类的输出。|625348|public+class+TestClass+{

++++public+static+void+main(String[]+args)+{
++++++++GenericRun+m+=+new+GenericRun();
++++++++m.run(new+ArrayList<>());
++++++++m.run(new+Integer(5));
++++++++m.run(5);

++++++++NotGenericRun+n+=+new+NotGenericRun();
++++++++n.run(new+ArrayList<>());
++++++++n.run(new+Integer(5));
++++++++n.run(13);
++++}

}|625349|该代码的输出如下：|625350|Generic+Run:+[]
Generic+Run:+5
Generic+Run:+5
Non+Generic+Run+List:+[]
Non+Generic+Run+Int:+5
Non+Generic+Run+Int:+13|625351|当您使用泛型运行时，正如我已经说过的，参数可能是任何对象，但是在仍然使用泛型的同时，还有其他限制参数的方法。|625352|public+class+GenericRun+{

++++public+<T>+void+run(T+object)+{
++++++++String+message+=+"Generic+Run:+";
++++++++System.out.println(message.concat(object.toString()));
++++}

}|625353|这就是怎么做的。|625354|public+class+GenericRun+<T>+{

++++public+void+run(T+object)+{
++++++++String+message+=+"Generic+Run:+";
++++++++System.out.println(message.concat(object.toString()));
++++}

}|625355|在本例中，您将像这样使用GenericClass：|625356|GenericRun<Integer>+m+=+new+GenericRun<Integer>();
m.run(new+Integer(5));
m.run(5);|625357|在创建类时，只应该说明它将被标记的价值。我想不出可能需要public+<T>+void+run(T+object)+{+...+}的场景，但当您需要获得每个参数的方法时，或者您不知道参数将是什么(但它确实不太可能)时，就可能发生这种情况。当您在运行时使用泛型时，我会更经常地这样想：|625358|public+class+GenericRun+<T>+{

++++public+void+run(T+object)+{
++++++++...
++++}

}|625359|I正在搜索泛型方法+这里+的用法，您可以阅读更多关于为什么我们需要泛型方法的文章。|BOLD|625360|下面是另一个例子：|625361|public+class+GenericRun+{

++++public+<T>+void+run(T[]+inputArray)+{
++++++++for+(T+element+:+inputArray)+{
++++++++++++System.out.printf("%25s+",+element);
++++++++}
++++++++System.out.println();
++++}

}|625362|使用该类，可以使用单个泛型方法打印不同类型的数组：|625363|public+class+TestClass+{

++++public+static+void+main(String[]+args)+{
++++++++GenericRun+m+=+new+GenericRun();
++++++++//+Create+arrays+of+Integer,+Double+and+Character
++++++++Integer[]+intArray+=+{+1,+2,+3,+4,+5+};
++++++++Double[]+doubleArray+=+{+1.1,+2.2,+3.3,+4.4+};
++++++++Character[]+charArray+=+{+'H',+'E',+'L',+'L',+'O'+};

++++++++System.out.println("Array+integerArray+contains:");
++++++++m.run(intArray);+//+pass+an+Integer+array

++++++++System.out.println("\nArray+doubleArray+contains:");
++++++++m.run(doubleArray);+//+pass+a+Double+array

++++++++System.out.println("\nArray+characterArray+contains:");
++++++++m.run(charArray);+//+pass+a+Character+array
++++}

}|625364|我希望我回答了你的问题。|625365|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.oracle.com/javase/tutorial/extra/generics/methods.html^0|6|11|3A|D|0|0|8|A|J|D|0|0|0|0|0|0|0|0|C|C|0|0|S|11|0|0|0|9|D|S|A|2|0|0|0|9|0|0|0|P|0|0|0|C|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|G|5|H|7|1Y|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1Z|8|@$9|20|A|21|B|C]|$9|22|A|23|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|24|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|25|8|@]|D|@]|E|$]]|$1|Q|3|R|5|H|7|26|8|@]|D|@]|E|$I|J]]|$1|S|3|T|5|6|7|27|8|@]|D|@]|E|$]]|$1|U|3|V|5|H|7|28|8|@]|D|@]|E|$I|J]]|$1|W|3|X|5|6|7|29|8|@]|D|@]|E|$]]|$1|Y|3|Z|5|H|7|2A|8|@]|D|@]|E|$I|J]]|$1|10|3|11|5|6|7|2B|8|@$9|2C|A|2D|B|C]]|D|@]|E|$]]|$1|12|3|13|5|H|7|2E|8|@]|D|@]|E|$I|J]]|$1|14|3|15|5|6|7|2F|8|@$9|2G|A|2H|B|C]]|D|@]|E|$]]|$1|16|3|17|5|H|7|2I|8|@]|D|@]|E|$I|J]]|$1|18|3|19|5|6|7|2J|8|@$9|2K|A|2L|B|1A]|$9|2M|A|2N|B|1A]]|D|@$9|2O|A|2P|1|2Q]]|E|$]]|$1|1B|3|1C|5|6|7|2R|8|@$9|2S|A|2T|B|1A]]|D|@]|E|$]]|$1|1D|3|1E|5|H|7|2U|8|@]|D|@]|E|$I|J]]|$1|1F|3|1G|5|6|7|2V|8|@$9|2W|A|2X|B|1A]]|D|@]|E|$]]|$1|1H|3|1I|5|H|7|2Y|8|@]|D|@]|E|$I|J]]|$1|1J|3|1K|5|6|7|2Z|8|@$9|30|A|31|B|1A]]|D|@]|E|$]]|$1|1L|3|-4|5|6|7|32|8|@]|D|@]|E|$]]]|1M|$1N|$5|1O|1P|1Q|E|$1R|1S]]]]

First of all I will start with the meaning of <code>public &lt;T&gt; void run(T object) { ... }</code>. Yes when you use that kind of code you than you may use any object as a parameter of run. If you want to restrict the arguments of this function to a specific interface, class or its sub classes you can just write code like <code>NotGenericRun</code> which is shown below.

<pre><code>public class NotGenericRun {

 public void run(ArrayList&lt;?&gt; list) {
 String message = "Non Generic Run List: ";
 System.out.println(message.concat(list.toString()));
 }

 public void run(int intValue) {
 String message = "Non Generic Run Int: ";
 System.out.println(message.concat(String.valueOf(intValue)));
 }

}
</code></pre>

Here I tested output of <code>GenericRun</code> and <code>NotGenericRun</code> classes. 

<pre><code>public class TestClass {

 public static void main(String[] args) {
 GenericRun m = new GenericRun();
 m.run(new ArrayList&lt;&gt;());
 m.run(new Integer(5));
 m.run(5);

 NotGenericRun n = new NotGenericRun();
 n.run(new ArrayList&lt;&gt;());
 n.run(new Integer(5));
 n.run(13);
 }

}
</code></pre>

Output of this code was following:

<pre><code>Generic Run: []
Generic Run: 5
Generic Run: 5
Non Generic Run List: []
Non Generic Run Int: 5
Non Generic Run Int: 13
</code></pre>

When you use Generic run as I already said arguments may be any object but there is other way of restricting the arguments while still using generics.

<pre><code>public class GenericRun {

 public &lt;T&gt; void run(T object) {
 String message = "Generic Run: ";
 System.out.println(message.concat(object.toString()));
 }

}
</code></pre>

This is how.

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

 public void run(T object) {
 String message = "Generic Run: ";
 System.out.println(message.concat(object.toString()));
 }

}
</code></pre>

In this case you'll be using <code>GenericClass</code> like this:

<pre><code>GenericRun&lt;Integer&gt; m = new GenericRun&lt;Integer&gt;();
m.run(new Integer(5));
m.run(5);
</code></pre>

and only value that it will be tacking should be stated while creating class. I can't think of scenario when <code>public &lt;T&gt; void run(T object) { ... }</code> may be needed but it might occur when you'll need the method to get every argument or you don't know what arguments will be (but it's really less likely). I think more often when you'll be using generics with run like this: 

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

 public void run(T object) {
 ...
 }

}
</code></pre>

I was searching about usage of generic methods <a href="https://docs.oracle.com/javase/tutorial/extra/generics/methods.html" rel="nofollow">here</a> you can read more about why may we need generic methods.

Here is another example:

<pre><code>public class GenericRun {

 public &lt;T&gt; void run(T[] inputArray) {
 for (T element : inputArray) {
 System.out.printf("%s ", element);
 }
 System.out.println();
 }

}
</code></pre>

Using this class you can print array of different type using a single Generic method: 

<pre><code>public class TestClass {

 public static void main(String[] args) {
 GenericRun m = new GenericRun();
 // Create arrays of Integer, Double and Character
 Integer[] intArray = { 1, 2, 3, 4, 5 };
 Double[] doubleArray = { 1.1, 2.2, 3.3, 4.4 };
 Character[] charArray = { 'H', 'E', 'L', 'L', 'O' };

 System.out.println("Array integerArray contains:");
 m.run(intArray); // pass an Integer array

 System.out.println("\nArray doubleArray contains:");
 m.run(doubleArray); // pass a Double array

 System.out.println("\nArray characterArray contains:");
 m.run(charArray); // pass a Character array
 }

}
</code></pre>

I hope I answered your question.

I am reading generics and tried writing the below code. There are no compilation error.

<pre><code>import java.util.*;

public class JavaApplication14 {

 public&lt;T&gt; void run (T obj ) {
 //Do Something
 }

 public static void main(String[] args) { 
 JavaApplication14 m= new JavaApplication14();
 m.run(new ArrayList&lt;&gt;()); 
 m.run(new Interger(5);
 m.run(5);
 }
}
</code></pre>

If the function is

<pre><code> public&lt;T extends Number&gt; void run (T obj) {
 //Do Something
 }
</code></pre>

It makes sense as we can restrict the arguments of this function to a Number and its subtypes. But am terribly confused what the function 'run' without any bound mean?
Can it now take any object as the argument ? In what scenario do i need to use such a function with generics ?

What does public<T> void run (T object ) { } means?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我正在阅读泛型，并尝试编写以下代码。没有编译错误。import java.util.*;public class JavaApplication14 { public<T> void run (T obj ) { //Do Something } public static void ma...

问public<T> void运行(T对象){}是什么意思？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问public<T> void运行(T对象){}是什么意思？EN