这种函数声明是什么意思：void test(String s, Object... args) {}

这种函数声明是什么意思：void test(String s, Object... args) {}
Object后面跟三个"."是什么意思啊？

14 个解决方案

#1

void test() 参数个数不定，但至少还有String s，后面的参数Object可以0或多个，但有个上限。

#2

不定参
1.5新增的
将下面2个方法合二为一
void test(String s, Object args) {}
void test(String s, Object[] args) {}


不过Object[] 应该不存在这种问题 
Object[]也是Object

#3

可以通过args.length()来判断传进来多少个参数，虽然类型是Object，但可以传进来int,char等等基本类型的参数。

#4

例如你的声明：
public static void testArgs(String s1,Object...o){
   int length = o.length;
   System.out.println(s1);
   for (Object tmp : o){
      System.out.println(tmp);
   }
}

那么你调用的时候下面都合法：
testArgs("1111");
testArgs("1111","2222","3333");
testArgs("1111","2222","3333",123456);

注意，这种声明不是JDK1.5的新功能，并且
void test(String s, Object...args) {}
void test(String s, Object[] args) {}
这两种定义根本就是两码事，是完全不同的概念

ls的所说的
void test(String s, Object args) {}
void test(String s, Object[] args) {}
不是lz所问的void test(String s, Object...args) {}

#5

注意，这种声明不是JDK1.5的新功能，并且
void test(String s, Object...args) {}
void test(String s, Object[] args) {}
这两种定义根本就是两码事，是完全不同的概念

======================================================
这种声明就是Java 1.5的新特性

两种定义虽然不是同一回事，但传递进来的Object...参数确实被放进了一个Object[]数组中

所以功能上两者是一样的，只不过调用的格式不一样而已

#6

jk88811(你的就是我的，我的还是我的~!) ( ) 信誉：100    Blog   加为好友  2007-04-07 23:19:23  得分: 0  
 
 
   注意，这种声明不是JDK1.5的新功能，并且
void test(String s, Object...args) {}
void test(String s, Object[] args) {}
这两种定义根本就是两码事，是完全不同的概念

======================================================
这种声明就是Java 1.5的新特性

两种定义虽然不是同一回事，但传递进来的Object...参数确实被放进了一个Object[]数组中

所以功能上两者是一样的，只不过调用的格式不一样而已
  
 ======================================================

你可以测试一下，不管是jdk5还是jdk6,
testArgs("1111");
testArgs("1111","2222","3333");
testArgs("1111","2222","3333",123456);
都是正确的，但写成下面的形式
public static void testArgs(String s1,Object[]o){
   int length = o.length;
   System.out.println(s1);
   for (Object tmp : o){
      System.out.println(tmp);
   }
}
跟部就通不过编译 ~你自己可以试一下嘛，不能只凭感觉

#7

daniel_kaka() ( ) 信誉：100    Blog   加为好友  2007-04-07 23:10:29  得分: 0  
 
   例如你的声明：
public static void testArgs(String s1,Object...o){
   int length = o.length;
   System.out.println(s1);
   for (Object tmp : o){
      System.out.println(tmp);
   }
}

那么你调用的时候下面都合法：
testArgs("1111");
testArgs("1111","2222","3333");
testArgs("1111","2222","3333",123456);

注意，这种声明不是JDK1.5的新功能，并且
void test(String s, Object...args) {}
void test(String s, Object[] args) {}
这两种定义根本就是两码事，是完全不同的概念

ls的所说的
void test(String s, Object args) {}
void test(String s, Object[] args) {}
不是lz所问的void test(String s, Object...args) {}
  
 
==============================================

既然你说 不是1.5的新增的功能 
那你去1.4试试咯~~~你在1.5 1.6试 能证明我说的"1.5新增的" 是错的吗?

再者  我说的是将下面这2种方法合二为一有错吗???
若在1.5之前  
对于void test(String s, Object[] args) {} 这种函数声明 
即便是第二个参数只有1个Object 也必须包装在数组中
只有test("1", new Object[]{"1"});  才是正确的 

但是在1.5中 如果函数声明定义为
void test(String s, Object... args) {}
那就省去了 包装在数组中的动作

请问  我说的哪里不对了?????
我根本就没说 2个方法是一样的





一点逻辑都没

#8

你可以测试一下，不管是jdk5还是jdk6,
testArgs("1111");
testArgs("1111","2222","3333");
testArgs("1111","2222","3333",123456);
都是正确的，但写成下面的形式
public static void testArgs(String s1,Object[]o){
   int length = o.length;
   System.out.println(s1);
   for (Object tmp : o){
      System.out.println(tmp);
   }
}



===================================================


1.5只是提供了一种不定参的函数声明方式  
你都不使用这种函数声明  就想使用不定参  有这么好的事情????

再说了  你这个例子能说明 不定参不是1.5的新特性??????
唉

#9

daniel_kaka() ( ) 信誉：100    Blog   加为好友  2007-04-07 23:02:56  得分: 0  
 
 
   可以通过args.length()来判断传进来多少个参数，虽然类型是Object，但可以传进来int,char等等基本类型的参数。
  
 
============================================================

这也是1.5的新特性 如果没有auto boxing    根本不可能传int,char等基本类型进来
不行 自己反编译看看就知道了

#10

老兄，何必那么激动~
你说的void test(String s, Object... args) {}是1.5特性没错没错~
但是
void test(String s, Object... args) {}和
void test(String s1,Object[]o){}
根本就是两中不同的函数定义，更不可能等价。
对于void test(String s, Object... args) {}下面的调用形式
testArgs("1111");
testArgs("1111","2222","3333");
testArgs("1111","2222","3333",123456);
test("1111",new Object[]{"2222","3333",123456});
都能编译通过，
void test(String s1,Object[]o){}都无法编译通过，
的形式调用，因此，这个函数不是不定参数，它只是普通的数组参数。

#11

.........................................
我没说等价啊~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~`

其实你反编译出来看看就知道了 只不过是编辑器多加了一个解释  
虚拟机还是只知道只有一个 void test(String s1,Object[]o){}声明
而没有void test(String s1,Object... o){}声明

#12

抱歉，有一个地方说错了：
只有test("1111",new Object[]{"2222","3333",123456});的调用才能在2种定义中都通过，
而testArgs("1111");testArgs("1111","2222","3333");testArgs("1111","2222","3333",123456);这类的调用只能在void test(String s, Object... args) {}中通过，void test(String s1,Object[]o){}无法通过，虽然1.5.0里面说了用新的void test(String s, Object... args) {}定义函数取代老的void test(String s1,Object[]o){}，但并没说明void test(String s1,Object[]o){}和void test(String s, Object... args) {}是等价的，因为老的定义方式不能接受新的testArgs("1111","2222","3333");调用形式，因此不能说明这两种形式等价，而只能说明void test(String s, Object... args) {}这种定义取代了void test(String s1,Object[]o){}这种老的定义，而事实上正是如此，jdk5.0+里面的定义基本上都从老的形式转变到新的定义形式了。

因此，下面的结论：
1，void test(String s1,Object[]o){}是老的不定参数定义形式，并且被现在的void test(String s1,Object... args){}逐步代替（但是还可以继续使用，JDK向下兼容）；
2，新的不定参数调用形式不一定适合老调用方式，但老的肯定是用于新的方式，形如
testArgs("1111");testArgs("1111","2222","3333");testArgs("1111","2222","3333",123456);调用；
3，void test(String s1,Object[]o){}和void test(String s1,Object... args){}不等价，而是void test(String s1,Object... args){}包含void test(String s1,Object[]o){}的定义。

我这样说不知道大家看得明白不。

#13

反编译看原结构本来就不现实，若是看实现思路还可以:
因为反编译出来的东西不一定就是源代码，只能说跟源代码功能一样，
对于一个复杂的class，反编译后能有70%代码一样已经很不错了。

#14

呵呵呵呵 Compiler sugar