思路： 
     实现反转：就需要将数组最远端元素和最近端为止互换
 ?    定义两个变量，保存数组的最小索引和最大索引
 ?    让两个索引上的元素交换位置
 ?    最小的索隐变量++，最大的索引变量，在此交换位置
 ?    最小的索引超过了最大索引，数组反转结束

//准备一个需要反转的数组  int[] arr ={1,2,3,4,5,6}
//定义两个索引变量,一个索引变量指向最小索引，一个索引变量指向最大索引
int[] arr = {1,2,3,4,5,6};
int min = 0;
int max = arr.length-1;
//遍历数组，让两个索引变量产生变化
min++;
max++;
条件min<max
交换最小索引元素和最大索引元素;需要定义第三方变量。
int temp = 0;
temp=arr[min];//把最小的索引赋值给第三方变量
arr[min]= arr[max];//把最大的索引元素赋值给最小的索引元素
arr[max]= temp;//把第三方变量的值赋值给最大索引的元素

解题过程：
public static void main(String[] args){
    int[] arr = {1,2,3,4,5,6};
    //遍历数组 for    for(int min = 0,int max = arr.length-1;min < max;min++,max--){
         int temp =0;
        temp = arr[min];
        arr[min]=arr[max];
        arr[max]=temp; 
    }
}
//查看反转之后的数组内容  遍历数组
for（int a=0;a<length;a++）{
    System.out.println(arr[a]);
}

int[] arr = {1,2,3,4,5};
//遍历数组
for(int i =0;i<lenght/2;I++ ){
    //交换变量
    int temp = 0;
    temp = arr[i];
    arr[i]=arr[arr.length-1-i] ;
    arr[arr.length-1-i]=temp;
}
for（int a=0;a<length;a++）{
    System.out.println(arr[a]);
}

　        数组的数据类型[][] 数组名称 = new 数组的数据类型[长度1][长度2];
　　　　　　长度1 不可省略 代表该二维数组里面存储的元素个数
　　　　　　长度2 可以省略 代表该二维数组里面的元素（数组里面的元素个数）而且它里面数组元素个数一样


　　　　　　如：int[][]arr = new int[3][2];
　　　　　　长度3------》该arr数组里面有3个元素（数组）
　　　　　　长度2------》该arr数组里面的每个数组元素都有两个元素
　　　　　　int[][] arr={{0,0},{0,0},{0,0}};

        

　　　　数组的数据类型[][] 数组名称 = new  数组的数据类型[][]{{元素1，元素2..},{元素1，元素2,元素3，..},{元素1，元素2..}.....};

    　　数组的数据类型[][] 数组名称 = {{元素1，元素2，元素3...}，{元素1，元素2..}，{元素1，元素2...}...};

    数组名称[索引]----》访问的是二维数组的元素
         //访问二维数组当中一维数组的元素
         数组名称[二维数组的索引值][一维数组里面的元素索引值]
         如：int[][] arr = {{10,20,30},{30,40,80},{15,100}};
        //访问arr数组房中的10元素
        arr[0][0] =10;
        //访问数组的80元素
        arr[1][2] = 80;
   

        //publlic 公共的 修饰符
        //static  静态的 修饰符
        //void    空的，无效的 返回值类型
            public static void main(String[] args){
            
            //方法体
            
        }

1. 　　　　　　  单独调用：方法名称 (参数具体值)
2. ?            打印调用：System.out.println(方法名称(参数具体值))
3. ?            赋值调用：数据类型  变量名称  =  方法名称(参数具体值);

备注：当返回值为void的时候，这种方法只能单独调用，不能进行打印调用或者复制调用。
返回值类型一般可以理解为数据类型(基本数据类型和引用数据类型)，此外还包含一种类型void类型
当方法执行完毕不需要给程序的调用者返回任何的数据结果时，可以指定该方法的返回值类型为void。此时只能【单独调用】。

顺序：

　　　　1.方法开始调用

　　　　2.实际参数传递

　　　　3.方法体内执行

　　　　4.方法结束返回

　　　　5.将返回值返回给调用位置

注意事项

1.方法定义的先后顺序无所谓

2.方法定义不能嵌套，不能在一个方法内部定义另外一个方法

3.方法定义之后，自己不会执行；如果希望执行，一定要进行方法的调用。

    public static void main(String[] args){
        int[] arr={1,2,3,4,5};
        //调用方法，传递数组
        println(arr);
    }
    /*
        创建方法，方法接受数组类型的参数
        进行数组的遍历
    */
    public stetic void println(int[] arr){
        //数组遍历
        for(int i =0;i<=arr.length-1;i++){
            System.out.println(arr[i]);
        }
        
    }

public static void main(String[] args){
        //调用方法，接收数组的返回值
        //接收到的是数组的内存地址
        int[] arr = getArray();
        System.out.println(arr);// 此时是一个内存地址哈希值
    }

        /*
            创建方法，返回值是数组类型
            return 返回数组的内存地址
        */
       public static int[] getArray() {
       int[] arr = {1,3,5,9,11};
       // 此时返回数组的内存地址，返回给调用者
       return arr;
   }

实现不了

public static void main(String[] args) {
        int a = 10;
        int b = 20;
        change(a,b);
        System.out.println(a);// a = 10
        System.out.println(b);// b = 20    
    }
    public static void change(int a,int b) {
        a = a+ b;//  a = 30
        b = b + a;// b = 50 
    }

可以实现
 public static void main(String[] args) {
         int[] arr = {10,20};
         changeArray(arr);
         System.out.println(arr[0]);// arr[0] = 10?---->30
         System.out.println(arr[1]);// arr[1] = 20?---->50
     }   
     public static void changeArray(int[] arr) {
         arr[0] = 30;
         arr[1] = 50;
     }