黑马程序员技术交流社区

标题: 我可以吧main方法里参数 写成 String... args 嘛 [打印本页]
作者: 崔自成    时间: 2013-3-17 18:38
标题: 我可以吧main方法里参数 写成 String... args 嘛
本帖最后由 崔自成 于 2013-3-18 10:18 编辑

我发现我可以把 main方法里的String[] agrs  用 String... args 来代替，编译没问题，而且运行时也不报”没有找到主方法的错误“
  1. class  Test5
  2. {
  3.         public static void main(String...  args)
  4.         {
  5.                 System.out.println(args);
  6.                
  7.         }
  8. }
复制代码
  1. class  Test6
  2. {
  3.         public static void main(String[]  args)
  4.         {
  5.                 System.out.println(args);
  6.                
  7.         }
  8. }
复制代码
这两段代码的输出结果都是一样的    [Ljava.lang.String;@1ff0dde
String[] args 和 String... args 作为方法参数 有哪里不同，我该这么理解？

作者: 黄基焜    时间: 2013-3-17 19:05
String... args是可变参数，1.5之后的新特性。是String[] args 的增强。
参数列表String[] args 是要传递元素数组，而可变参数String... args可以直接传递元素，是方法里面自动封装数组。
作者: 罗海清    时间: 2013-3-17 19:50
本帖最后由 罗海清 于 2013-3-17 19:52 编辑

不知道，5.0新特性里说到可变参数，
add(int... arr);
和add(int[] arr)
很像，估计jvm在执行main函数的时候，
如果有参数，就会创建一个args字符串数组，
可变参数也是，有几个参数来，就创建多大长度
的数组。
不过以前的程序都是不用可变参数作为main函数的参数的，
如果用可变参数作为参数，jdk5.0之前的编译器会报错。

经过用反射，可以得出，实际上得出的.class在二进制时的状态是一样的，因此，可以用可变参数，不过仅仅是。class文件可以运行，源文件是不能被5.0之前的javac编译

import java.lang.reflect.*;
class Demo
{
        public static void main(String... args)throws Exception
        {
                System.out.println("555555555");
                Method main = Demo.class.getMethod("main",String[].class);//在用反射时，这里就不能用可变参数了。
                System.out.println(main);//无论采用哪个方式的参数，得到的都是public static void Demo.main(java.lang.String[]) throws java.lang.Exception
        }
}

作者: HM刘博    时间: 2013-3-17 20:14
String... args 是jdk1.5之后的新特性，称之为可变参数。之前我们定义可变参数是采用String[] args的方法来声明，但是String...  args在应用上更加灵活和简便
例如
  1. class StringDemo0
  2. {
  3.         public static void callMe1(String[] args)
  4.                 {  
  5.                 System.out.println(args.getClass() == String[].class);  
  6.                            for(String s : args)
  7.                             {  
  8.                                   System.out.println(s);  
  9.                              }  
  10.     }  
  11.       
  12.     public static void callMe2(String... args)
  13.        {  
  14.                 System.out.println(args.getClass() == String[].class);  
  15.                  for(String s : args)
  16.                  {  
  17.                      System.out.println(s);  
  18.                  }  
  19.            }  

  21.         public static void main(String[] args)
  22.         {
  23.                 callMe1(new String[] {"a", "b", "c"});  
  24.                                 callMe2("a", "b", "c");  

  26.         }
  27. }
复制代码
在这组代码中我们可以这样调用
callMe1(new String[] {"a", "b", "c"});  
callMe2(new String[] {"a", "b", "c"});  
以及这样调用
callMe1(new String[] {"a", "b", "c"});  
callMe2("a", "b", "c");  

但是不能进行这样调用
callMe1("a", "b", "c");  


这就是String... args定义方法的灵活之处。并且当一个方法定义中有String... args形参时，实参传递的参数个数可以是少于最大个数的任意个，可以不传参数。



作者: 沈子豪    时间: 2013-3-17 20:21
String... args 是5.0之后的新特性，称之为可变参数.也就是以为着这样定义的话5.0之前的jdk是不能编译的,String... args 的使用相对于String[] args更加方便和灵活,jdk版本的提高就是要趋于更加方便和便于使用的方向.



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2