8个答案 按时间排序 按投票排序

1 0

注意：void f(T... x)　的含义是　后面的参数必须是统一的一个类型，比如int 必须全int String 必须全string,你的类型不统一，虚拟机就只能更具自己的判断来处理。说不定你用jdk7就会是object

2012年6月27日 08:28

mayufenga1
97
0 0 1

• 添加评论

1 0

java.lang.Number (implements java.io.Serializable)
         java.lang.Byte (implements java.lang.Comparable<T>)
         java.lang.Double (implements java.lang.Comparable<T>)
         java.lang.Float (implements java.lang.Comparable<T>)
         java.lang.Integer (implements java.lang.Comparable<T>)
         java.lang.Long (implements java.lang.Comparable<T>)
         java.lang.Short (implements java.lang.Comparable<T>)
java.lang.String (java.io.Serializable, implements java.lang.CharSequence, java.lang.Comparable<T>)

我猜应该和实现的接口的顺序有关系吧。。。

估计是按照顺序匹配的（我猜的），如果是integer在前,先把integer和string比（不匹配再依次把string当Serializable，CharSequence、Comparable），再把integer当做Comparable和string（依次xxx xxx xxx） 比较，如果类型相同，就当做是Comparable传进去当参数

如果是string在前，估计先和string和integer（依次Comparable，Number，Serializable）比，再把string当Serializable和integer比。。。

总归是这么比较出来的，所以应该是和比较的顺序有关吧。。。。

2012年6月26日 16:21

asyty
1942
0 1 29

• 1条评论

1 0

对于编译器来说，数字 会被打包为Integer类型
下面是 String  Integer Number 三个对象
Integer extends Number

对于最后一行来看，gm.f("123", 12)

编译器 看做 gm.f(String ,Integer); 再变为 T[] 首先拿到的是String的 Serializable 接口，在去找Integer有没有Serializable接口，如果有那么就用Serializable

其实我们把 顺寻反过来看就知道了
gm.f(12,123") 这里输出的就是 Comparable

先去找Integer的接口

public final class String implements java.io.Serializable, Comparable<String>, CharSequence

public final class Integer extends Number implements Comparable<Integer>

public abstract class Number implements java.io.Serializable

2012年6月26日 16:14

kidding87
1566
1 1 19

• 1条评论

0 0

System.out.println(new Serializable[]{"123", 12});
"123" 是String，String实现了Serializable接口
12 会被装箱为Integer，Integer继承于Number类，Number实现了Serializable接口

	public class GenericMethods {
		public <T> void f(T... x) {
			System.out.println(x.getClass().getName());
		}

		/**
		 * @param args
		 */
		public static void main(String[] args) {
			// TODO Auto-generated method stub
			GenericMethods gm = new GenericMethods();
			gm.f("123", "234");
			gm.f(123, 2132);
			gm.f(gm, gm);
			gm.f(23, "1232", gm);
			gm.f("123", 12);
			
			// 楼主看这里，和泛型没有关系！
			System.out.println(new String[]{"123", "234"});
			System.out.println(new Integer[]{123, 2132});
			System.out.println(new GenericMethods[]{gm, gm});
			System.out.println(new Object[]{23, "1232", gm});
			System.out.println(new Serializable[]{"123", 12});
		}
	}

JDK 中 String 的部分代码

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence
{
    /** The value is used for character storage. */
    private final char value[];

JDK 中 Integer 的部分代码

public final class Integer extends Number implements Comparable<Integer> {
    /**
     * A constant holding the minimum value an <code>int</code> can
     * have, -2<sup>31</sup>.
     */
    public static final int   MIN_VALUE = 0x80000000;

public abstract class Number implements java.io.Serializable {
    /**
     * Returns the value of the specified number as an <code>int</code>.
     * This may involve rounding or truncation.
     *
     * @return  the numeric value represented by this object after conversion
     *          to type <code>int</code>.
     */
    public abstract int intValue();

2012年6月27日 13:22

lijianghui2000
31
0 0 0

• 添加评论

0 0

这个是跟jdk的编译有关的，其实编译后的字节码已经确定了类型。反编译的代码如下：

	public GenericMethods()
	{
	}

	public transient void f(Object x[])
	{
		System.out.println(((Object) (x)).getClass().getName());
	}

	public static void main(String args[])
	{
		GenericMethods gm = new GenericMethods();
		gm.f(new String[] {
			"123", "234"
		});
		gm.f(new Integer[] {
			Integer.valueOf(123), Integer.valueOf(2132)
		});
		gm.f(new GenericMethods[] {
			gm, gm
		});
		gm.f(new Object[] {
			Integer.valueOf(23), "1232", gm
		});
		gm.f(new Serializable[] {
			"123", Integer.valueOf(12)
		});
		gm.f(new Comparable[] {
			Integer.valueOf(12), "123"
		});
	}

至于为什么是这个样子，我们用下边的代码来看一下：

System.out.println(Integer.class.getInterfaces()[0].getName());
System.out.println(String.class.getInterfaces()[0].getName());

2012年6月27日 13:06

guazi
454
0 0 14

• 添加评论

0 0

记得在张老师的java基础提高视频里曾听到过，这个涉及到参数类型推断了，
http://docs.oracle.com/javase/specs/jls/se7/html/jls-15.html#jls-15.12.2.7
怎么根据多个参数类型推断出一个类型，里面有一堆数学公式。
我看我们一般人就别去搞这种数学的东西了吧。
你有兴趣可以研究下上面链接的15.12.2.7. Inferring Type Arguments Based on Actual Arguments

2012年6月26日 16:06

xpenxpen
203
0 0 18

• 添加评论

0 0

查了资料，我最后发现，其实不是泛型的问题

Interge和String等对象都实现了Serializable接口，所以这两个传进去，就把T自动匹配成Serializable对象了！！

2012年6月26日 14:28

asyty
1942
0 1 29

• 2条评论

0 0

你试试这个

public class Test {
	public <T> void f(T... x) {
		for(int i = 0; i < x.length; i++)
			System.out.println(x[i].getClass().getName());
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Test gm = new Test();
		gm.f("123", "234");
		gm.f(123, 2132);
		gm.f(gm, gm);
		gm.f(23, "1232", gm);
		gm.f("123", 12);
	}
}

T...x 表示的是类型为T的数组序列，只有一个类，你参数都是一样的时候当然正确，不一样的时候，把string和int封装成一个类(Serializable)里的成员吧估计

2012年6月26日 12:50

asyty
1942
0 1 29

• 2条评论