我在编辑了一断代码之后，我想让变量重载。
比如说，我编辑了一段代码，int[] arr={3,6,5,1,8,9,};
class j0611//遍历数组的值
{
        public static void main(String[] args)
        {
                int sum=0;
                System.out.println("length:"+arr.length);for (int x=0;x<arr.length ;x++ )
                {System.out.println("arr["+x+"]="+arr[x]+";");sum +=arr[x];
                }System.out.println(sum);
                print(arr);
                print(arr);
                print(arr);
                print(arr); //到了这里。我感到很爽。
                print99(arr); //我想重载变量arr。赋给他一个更长的数组。
//int[]arr={5,6,5,5,1,2,3,5,2,2,6,,2,2};
//思路，使用int赋值，失败。
//思路，使用函数赋值，报错。
//思路，int arr=null。不报错。但是与需求不相符。
/*
        public static void print99(int[]arr)
        {
                int[]arr={5,6,5,5,1,2,3,5,2,2,6,6,2,2};
                for (int x=0;x<arr.length ;x++ )
                {

                        if(x!=arr.length-1)
                                System.out.print(arr[x]+"、");
                        else
                                System.out.println(arr[x]);
                }
        }               
*/


               
               
        }
        public static void print(int [] arr)
        {
                for (int x=0;x<arr.length ;x++ )
                {

                        if(x!=arr.length-1)
                                System.out.print(arr[x]+"、");
                        else
                                System.out.println(arr[x]);
                }
        }
}
求高手给意见。

1. public static void main(String[] args) {
   
2.                 int[] arr = { 3, 6, 5, 1, 8, 9, };
   
3.                 int sum = 0;
   
4.                 System.out.println("length:" + arr.length);
   
5.                 for (int x = 0; x < arr.length; x++) {
   
6.                         System.out.println("arr[" + x + "]=" + arr[x] + ";");
   
7.                         sum += arr[x];
   
8.                 }
   
9.                 System.out.println(sum);
   
10.                 print(arr);
    
11.                 print99(new int[] { 5, 6, 5, 5, 1, 2, 3, 5, 2, 2, 6, 2, 2 });
    
12.         }
    
13.         public static void print99(int[] arr) {
    
14.                 for (int x = 0; x < arr.length; x++) {
    
15.                         if (x != arr.length - 1)
    
16.                                 System.out.print(arr[x] + "、");
    
17.                         else
    
18.                                 System.out.println(arr[x]);
    
19.                 }
    
20.         }
    
21.         public static void print(int[] arr) {
    
22.                 for (int x = 0; x < arr.length; x++) {
    
23. 
    
24.                         if (x != arr.length - 1)
    
25.                                 System.out.print(arr[x] + "、");
    
26.                         else
    
27.                                 System.out.println(arr[x]);
    
28.                 }
    
29.         }

复制代码

1. class j0611// 遍历数组的值
   
2. {
   
3.         public static void main(String[] args) {
   
4.                 int[] arr = { 3, 6, 5, 1, 8, 9, };
   
5.                 int sum = 0;
   
6.                 System.out.println("length:" + arr.length);
   
7.                 for (int x = 0; x < arr.length; x++) {
   
8.                         System.out.println("arr[" + x + "]=" + arr[x] + ";");
   
9.                         sum += arr[x];
   
10.                 }
    
11.                 System.out.println(sum);
    
12.                 print(arr);
    
13.                
    
14.                  print99(arr); // 重载变量arr。赋给他一个更长的数组。
    
15.                
    
16.         }
    
17. 
    
18.         public static void print99(int[] arr) {
    
19.                 arr = new int[]{ 5, 6, 5, 5, 1, 2, 3, 5, 2, 2, 6, 6, 2, 2 };
    
20.                 for (int x = 0; x < arr.length; x++) {
    
21.                         
    
22.                         if (x != arr.length - 1)
    
23.                                 System.out.print(arr[x] + "、");
    
24.                         else
    
25.                                 System.out.println(arr[x]);
    
26.                 }
    
27.         }
    
28. 
    
29.         public static void print(int[] arr) {
    
30.                 for (int x = 0; x < arr.length; x++) {
    
31. 
    
32.                         if (x != arr.length - 1)
    
33.                                 System.out.print(arr[x] + "、");
    
34.                         else
    
35.                                 System.out.println(arr[x]);
    
36.                 }
    
37.         }
    
38. }

复制代码

输出结果是：
length:6
arr[0]=3;
arr[1]=6;
arr[2]=5;
arr[3]=1;
arr[4]=8;
arr[5]=9;
32
3、6、5、1、8、9
5、6、5、5、1、2、3、5、2、2、6、6、2、2

你有两个地方错了；
第一.在print99方法里面，你试图重新定义一个重名的arr数值变量，这是不允许的，会和你函数参数名冲突；应把arr前面的int去掉；
arr = { 5, 6, 5, 5, 1, 2, 3, 5, 2, 2, 6, 6, 2, 2 };//这样是会报异常的，就是错的第二点，这样的数组常量，只能用来数组的初始化，而显然arr显然之前就初始化过了，所以这里要改为：
arr = new int[]{ 5, 6, 5, 5, 1, 2, 3, 5, 2, 2, 6, 6, 2, 2 };
希望可以解决你的问题。{:soso_e100:}

                 /*我也来说说自己的意见吧，
                  * 首先说下我对楼主问题的理解：
                  *         楼主定义了一个 int[] arr,
                  * 想通过函数print99(int[]arr) 改变arr的长度；
                  *
                  * 楼上的方法都是无法实现的。
                  * 许多编程语言都有2种方法将参数传递给方法------按值传递和按引用传递。
                  * 与其他语言不同，Java不允许程序员选择按值传递还是按引用传递各个参数，
                  * 基本类型(byte--short--int--long--float--double--boolean--char)的变量总是按值传递。
                  * 就对象而言，不是将对象本身传递给方法，而是将对象的的引用或者说对象的首地址传递给方法，
                  * 引用本身是按值传递的-----------也就是说，讲引用的副本传递给方法（副本就是说明对象此时有两个引用了），
                  * 通过对象的引用，方法可以直接操作该对象（当操作该对象时才能改变该对象，而操作引用时源对象是没有改变的）。
                  *
                  * 简单点说，不管你print99(int[]arr)传的参数名是否跟你定义的 arr相同，都会创建一个副本（且叫局部引用好了），
                  * 局部引用跟原始引用指向同一内存地址，所以再函数内对数组的改值操作 例：
                  *  public  void print99(int[]arr)
                  *  ｛
                  *           for (int x=0;x<arr.length ;x++ )
                  *                       arr[x]++;
                  *  ｝
                  *  会修改原始数组的值；
                  *  若是如下操作：
                  *   arr = new int[]{5,6,5,5,1,2,3,5,2,2,6,6,2,2};
                  *   只是改变了副本引用指向的地址，并不会改变原始引用指向的地址，所以，原始arr还是={3,6,5,1,8,9,};
                  *   
                  *   这样看来 要想改变数组长度，就要避免创建 副本引用。
                  *   大家可以讨论一下怎么避免创建 副本引用！
                  *   方法一：
                  *   不传参   public  void print99()   显然没有扩展性  
                  * */

其实int数组初生命的时候就规定了其大小，如果非要改变其大小，就要重新new一个数组然后赋值给它，如：int[] myArray = new int[6];
myArray = new int[10];
但是如果想动态的改变数组大小，楼主可以使用List来实现，如List<Integer> list = new ArrayList<Integer>();因为范型不支持基本数据类型，
所以只能用Integer，这样就可以动态的改变其大小