数组的注释

今日内容：

　数组

　方法

　　数组的反转

　　　　数组中的元素颠倒顺序，例如：原始数组为1，2，3，4，5数组反转之后为5，4，3，2，1

　　　方式一

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

//准备一个需要反转的数组  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){
            
            //方法体
            
        }

方法定义的完整格式：修饰符 返回值类型 方法名称（参数类型 参数名称,参数类型2 参数名称2）{}

修饰符：public static

返回值类型：void 方法最终产生的数据结果是什么

方法名称 ：方法的名字，名字自定义--标识符，采用小驼峰命名法，方法名后小括号一般都是方法

String[] args 参数（小括号里的为参数）--》就是变量 String[]参数类型 args参数名称

参数类型：进入方法中的数据是一个什么样的类型

参数名称：进入方法当中的数据对应的变量名称

方法体：方法需要执行的功能，由若干行代码组成

return：一般认为有两个作用，第一将后面的返回值返回给程序，第二停止当前正在执行的方法。

返回值：就是方法执行最终产生的数据结果。

备注：1.return后面的"返回值"，必须和方法声明的返回值保持一致

2.方法不允许嵌套，不允许定义在类的外面

3.方法只能并列，必须定义在类的里面

方法调用【重点】

 　　三种调用格式：

 　　　　

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

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

顺序：

　　　　1.方法开始调用

　　　　2.实际参数传递

　　　　3.方法体内执行

　　　　4.方法结束返回

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

注意事项

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

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

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

方法重载

　　功能

　　 　　对于功能类似的方法来说，因为参数列表不一样，却需要定义不同的方法名称，对于开发者来说，记忆那么多的功能化类似的不同方法名，非常麻烦。

 【如果在类中定义方法时，方法的参数列表不一致，虽然方法名一样，但是程序会认为这是一个新方法。】

　　好处：减少我们记忆方法名称的数量

　　方法重载（Overload）：在一个类型中，多个方法名称一样，但是参数列表不一样

　　好处：只需要记住唯一一个方法名称即可，就可以实现类似的多个功能。

　　 方法重载相关因素

　　　　1.参数个数不同（会认为是新方法）

　　　　2.参数类型不同

　　　　3.参数的多类型顺序不同。

 

　　方法重载与那些因素无关:

　　　　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;
   }

一个方法可以有0，1，多个参数；但是只能有0，1个返回值，不能有多个返回值。

如果我们希望一个方法当中产生的了多个结果数据，这些多个结果数据同时需要返回

解决方案：使用一个容器（数组）作为方法的返回值类型即可。

实现不了

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;
     }