blocks|key|1876123|text|这对我很有效|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1876124|public+static+<T>+void+x(T+a,+T+b,+Class<T>+cls)+{
}|code-block|syntax|javascript|1876125|现在可以编译以下代码|1876126|public+static+void+main(String[]+args)+throws+Exception+{
++++x(1,+2,+Integer.class);
}|1876127|这并不是|1876128|public+static+void+main(String[]+args)+throws+Exception+{
++++x(1,+"",+Integer.class);
}|1876129|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

This worked for me

<pre><code>public static &lt;T&gt; void x(T a, T b, Class&lt;T&gt; cls) {
}
</code></pre>

now this compiles

<pre><code>public static void main(String[] args) throws Exception {
 x(1, 2, Integer.class);
}
</code></pre>

and this does not 

<pre><code>public static void main(String[] args) throws Exception {
 x(1, "", Integer.class);
}
</code></pre>

blocks|key|1876131|text|如果我理解正确的话，一种方法是explicitly+specify+the+type+of+T，而不是让编译器在两个不同类型的对象作为参数传递的情况下推断它的类型是最直接的超类。以下面的内容为例：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1876132|public+class+Test+{
++++public+static+void+main(String[]+args)+{
++++++++Test.x(5.0,+5);++++++++++//+This+works+since+type+is+inferred+to+be+Number
++++++++Test.<Integer>x(5,+5);+++//+This+works+since+type+is+stated+to+be+Integer
++++++++Test.<Integer>x(5.0,+5);+//+This+doesn't;+type+is+stated+to+be+Integer+and+Double+is+passed+in
++++}

++++public+static+<T>+void+x(T+a,+T+b)+{
++++}
}|code-block|syntax|javascript|1876133|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.oracle.com/javase/tutorial/java/generics/methods.html^0|F|W|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]]]]

If I understand correctly, one way to do it is to <a href="https://docs.oracle.com/javase/tutorial/java/generics/methods.html">explicitly specify the type of T</a> instead of letting the compiler infer its type to be of the most direct superclass in the case of two objects of different types being passed in as arguments. Take something like this, for example:

<pre><code>public class Test {
 public static void main(String[] args) {
 Test.x(5.0, 5); // This works since type is inferred to be Number
 Test.&lt;Integer&gt;x(5, 5); // This works since type is stated to be Integer
 Test.&lt;Integer&gt;x(5.0, 5); // This doesn't; type is stated to be Integer and Double is passed in
 }

 public static &lt;T&gt; void x(T a, T b) {
 }
}
</code></pre>

blocks|key|1876138|text|您可能没有以泛型方式调用泛型方法，因此它被视为对x(Object+a,+Object+b)的调用。在此示例中：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1876139|public+class+Test+{

++static+<T>+void+x(T+a,+T+b)+{
++}

++public+static+void+main(String[]+args)+{
++++x(1,+2);+//+compiles
++++Test.<String>x(1,+2);+//+does+not+compile
++++Test.<String>x("a",+"b");+//+compiles
++}
}|code-block|syntax|javascript|1876140|对x的第一个调用不是泛型的，所以它会编译。第二个调用将T等同于String，因此它失败了，因为1和2不是Strings。第三个调用会编译，因为它正确地传入了Strings。|1876141|entityMap^0|O|L|0|0|R|1|V|6|1B|1|1D|1|1G|7|26|7|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]|$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|-4|5|6|7|15|8|@]|D|@]|E|$]]]|N|$]]

Presumably, you are not calling your generic method in a generic fashion, so it's treated like a call to <code>x(Object a, Object b)</code>. In this example:

<pre><code>public class Test {

 static &lt;T&gt; void x(T a, T b) {
 }

 public static void main(String[] args) {
 x(1, 2); // compiles
 Test.&lt;String&gt;x(1, 2); // does not compile
 Test.&lt;String&gt;x("a", "b"); // compiles
 }
}
</code></pre>

The first call to x is not made generically so it compiles. The second call equates <code>T</code> to <code>String</code>, so it fails because <code>1</code> and <code>2</code> are not <code>Strings</code>. The third call compiles because it properly passes in <code>Strings</code>.

blocks|key|1876143|text|如果我没理解错你的问题，你想要的是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1876144|x(10,+"x");|code-block|syntax|javascript|1876145|在编译时失败。现在考虑这样做：|1876146|Integer+i+=+10;
String+s+=+"x";
Object+o1+=+i;
Object+o2+=+s;
x(o1,+o2);|1876147|在这种情况下，它们都是对象-相同的类型。我不认为有任何方法可以真正执行你想要的东西-当你将你的参数转换为Object时，总是可以用两种不同的类型调用它，而不会出现任何警告/错误。|1876148|您可以像这样使用它来指定要使用的类型：|1876149|ClassName.<Type>x(obj1,+obj2);|1876150|这是唯一可行的方法。|1876151|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|Y|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|Z|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|10|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|11|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

If I understand your question correctly, you want this:

<pre><code>x(10, "x");
</code></pre>

to fail at compile time.
Now consider doing this:

<pre><code>Integer i = 10;
String s = "x";
Object o1 = i;
Object o2 = s;
x(o1, o2);
</code></pre>

In this case they are both objects - the same type. I don't think there is any way to really enforce what you want - when you cast your argument to Object it is always possible to call it with two different types without any warnings/errors.

You can specify the type you want to use by using it like this:

<pre><code>ClassName.&lt;Type&gt;x(obj1, obj2);
</code></pre>

And it's proably the only way to do it.

I would like to use a generic type to ensure, that the arguments of a method are of the same type, like this:

<pre><code>public static &lt;T&gt; void x(T a, T b)
</code></pre>

I would assume that the two arguments (a and b), that are passed to this method, would always have to be of the same type. But to my surprise I was able to pass arguments of any type (even primitives) to method x, as if T is erased to Object, no matter what arguments are passed.

The only work-around I found so far, was to use 'extends' like this:

<pre><code>public static &lt;T, U extends T&gt; void x(T a, U b)
</code></pre>

But although I can live with it, it is not what I wanted.

Is there a way to use a generic type to force the type of all arguments of a method?

Can the generic type of a generic Java method be used to enforce the type of arguments?

编译器

我想使用泛型类型来确保方法的参数具有相同的类型，如下所示：public static <T> void x(T a, T b)我假设传递给此方法的两个参数(a和b)必须始终属于同一类型。但令我惊讶的是，我能够将任何类型的参数(甚至是基本类型)传递给方法x，就好像T被擦除为Object一样，而不管传递的是什么参数。到目前...

问泛型Java方法的泛型类型能否用于强制参数类型？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问泛型Java方法的泛型类型能否用于强制参数类型？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问泛型Java方法的泛型类型能否用于强制参数类型？
EN