我发现我可以把 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 作为方法参数 有哪里不同，我该这么理解？

String... args是可变参数，1.5之后的新特性。是String[] args 的增强。
参数列表String[] args 是要传递元素数组，而可变参数String... args可以直接传递元素，是方法里面自动封装数组。

不知道，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
        }
}

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.            }  
    
20. 
    
21.         public static void main(String[] args)
    
22.         {
    
23.                 callMe1(new String[] {"a", "b", "c"});  
    
24.                                 callMe2("a", "b", "c");  
    
25. 
    
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形参时，实参传递的参数个数可以是少于最大个数的任意个，可以不传参数。

String... args 是5.0之后的新特性，称之为可变参数.也就是以为着这样定义的话5.0之前的jdk是不能编译的,String... args 的使用相对于String[] args更加方便和灵活,jdk版本的提高就是要趋于更加方便和便于使用的方向.