1.动态初始化
   初始化时只指定数组长度，由系统为数组分配初始值。
   格式：数据类型[] 变量名 = new 数据类型[数组长度];
   例如： int[] arr= new int[3];
       解释说明
           左边：
               int :说明数组中的元素类型是int类型
               []:说明这是一个数组
               arr:这是数组的名称
           右边：
               new:为数组申请内存空间
               int：说明数组中的元素类型是int类型
               [] ：说明这是一个数组
               3：数组长度，其实就是数组中的元素个数

2.静态初始化
   定义
       初始化时指定每个数组元素的初始值，由系统决定数组长度
   格式
       完整版格式
           数据类型[] 数组名 = new 数据类型[]{元素1,元素2,...};
       简化版格式
           数据类型[] 数组名 = {元素1,元素2,...};

定义完数组以后，我们怎么进行访问呢？不慌，我们有元素访问！

4.数组的元素访问

   数组变量访问方式
       格式：数组名
   数组内部保存的数据的访问方式
       格式：数组名 [索引]
       索引：是数组中数据的编号方式（index）
           作用于访问数组中的数据使用，数组名[索引] 等同于变量名，是一种特殊的变量名。
           特征：1.索引从0 开始 2.索引是连续的 3.索引逐一增加，每次加一

说了这么多，数组究竟有什么作用呢？接下来就给大家介绍三个数组常用的小操作。

1.遍历
就是将数组中的每个元素分别获取出来，就是遍历。遍历也是数组操作中的基石。

public class ArrayTest01 {
	public static void main(String[] args) {
		int[] arr = { 1, 2, 3, 4, 5 };
		System.out.println(arr[0]);
		System.out.println(arr[1]);
		System.out.println(arr[2]);
		System.out.println(arr[3]);
		System.out.println(arr[4]);
	}
}

2.获取数组元素数量
如果数组元素非常多，这种写法肯定不行，因此我们需要改造成循环的写法。数组的索引是 0 到 lenght-1 ，可以作为循环的条件出现

public class ArrayTest01 {
    public static void main(String[] args) {
        //定义数组
        int[] arr = {11, 22, 33, 44, 55};

        //使用通用的遍历格式
        for(int x=0; x<arr.length; x++) {
            System.out.println(arr[x]);
        }
    }
}

格式：数组名.length
范例：arr.length

3.获取元素最值
实现思路：（1）定义变量，保存数组0索引上的元素
（2）遍历数组，获取出数组中的每个元素
（3）将遍历到的元素和保存数组0索引上值的变量进行比较
（4）如果数组元素的值大于了变量的值，变量记录住新的值
（5）数组循环遍历结束，变量保存的就是数组中的最大值

  public class ArrayTest02 {
    public static void main(String[] args) {
        //定义数组
        int[] zu = {12, 45, 98, 73, 60};

        //定义一个变量，用于保存最大值
        //取数组中第一个数据作为变量的初始值
        int max = zu[0];

        //与数组中剩余的数据逐个比对，每次比对将最大值保存到变量中
        for (int x = 1; x < zu.length; x++) {
            if (zu[x] > max) {
                max = zu[x];
            }
        }

        //循环结束后打印变量的值
        System.out.println("max:" + max);
        int min = zu[0];
        for (int x = 1; x < zu.length; x++) {
            if (zu[x] < min) {
                min = zu[x];
            }
        }
        System.out.println("min:" + min);
    }
}

结果：max:98
min:12

另外，大家在数组操作中一定要注意两个小问题
   1.索引越界
       访问了数组中不存在的索引对应的元素，造成索引越界问题
           ArrayIndexOutOfBoundsException
   2.空指针异常
       访问的数组已经不再指向堆内存的数据，造成空指针异常
           NullPointerException
       null：空值，引用数据类型的默认值，表示不能指向任何有效对象

二、方法

1.定义

方法（method）是将具有独立功能的代码块组织成为一个整体，使其具有特殊功能的代码集

2.方法的格式

   定义格式
       Public static void 方法名() {
//方法体
}
范例：public static void IsNumber() {
   //方法体
}
调用格式
方法名（）；
范例
IsNumber();

注意
方法必须先定义，后调用，否则程序将报错

3.带参数的方法的定义和调用

定义格式
参数：由数据类型和变量名组成 - 数据类型变量名

参数范例：int a
public static void 方法名 (参数1) {
方法体;
}

public static void 方法名 (参数1, 参数2, 参数3...) {
   方法体;
}
           public static void isEvenNumber(int number){
...
}
public static void getMax(int num1, int num2){
...
}
       注意：方法定义时，参数中的数据类型与变量名都不能缺少，缺少任意一个程序将报错，方法定义时，多个参数之间使用逗号( ，)分隔
   调用格式
       方法名(参数)；

方法名(参数1,参数2);
范例
isEvenNumber(10);

getMax(10,20);
       方法调用时，参数的数量与类型必须与方法定义中的设置相匹配，否则程序将报错
   形参和实参
       形参
           1. 方法定义中的参数

等同于变量定义格式，例如：int number
实参
2. 方法调用中的参数

等同于使用变量或常量，例如： 10 number

4.带返回值方法的定义和调用

   定义格式
       public static 数据类型方法名 ( 参数 ) {
   return 数据 ;
}
       范例
           public static boolean isEvenNumber( int number ) {
   return true ;
}
public static int getMax( int a, int b ) {
   return 100 ;
}
       注意：方法定义时return后面的返回值与方法定义上的数据类型要匹配，否则程序将报错
   调用格式
       方法名 ( 参数 ) ;
数据类型变量名 = 方法名 ( 参数 ) ;
       范例
           isEvenNumber ( 5 ) ;
boolean flag = isEvenNumber ( 5 );
           也可以直接输出不定义变量名
               范例
                   System.out.println("最大值为：" + getMax(70,50));
       注意
           方法的返回值通常会使用变量接收，否则该返回值将无意义

说了这么多，那么有没有一种通用的格式呢？别急还真有，上菜。

方法的通用格式

   格式
       public static 返回值类型方法名(参数) {
方法体;
return 数据 ;
}
       解释
           public static    修饰符，目前先记住这个格式
           返回值类型   方法操作完毕之后返回的数据的数据类型，如果方法操作完毕，没有数据返回，这里写void，而且方法体中一般不写return
           方法名       调用方法时候使用的标识
           参数       由数据类型和变量名组成，多个参数之间用逗号隔开
           方法体       完成功能的代码块
           return       如果方法操作完毕，有数据返回，用于把数据返回给调用者
   定义方法时，要做到两个明确
       明确返回值类型
           主要是明确方法操作完毕之后是否有数据返回，如果没有，写void；如果有，写对应的数据类型
       明确参数
           主要是明确参数的类型和数量
   调用方法时的注意
       1.void类型的方法，直接调用即可
       2.非void类型的方法，推荐用变量接收调用

5.方法重载

   概念
       方法重载指同一个类中定义的多个方法之间的关系，满足下列条件的多个方法相互构成重载
（1）多个方法在同一个类中
（2）多个方法具有相同的方法名
（3）多个方法的参数不相同，类型不同或者数量不同
   注意
       重载仅对应方法的定义，与方法的调用无关，调用方式参照标准格式
       重载仅针对同一个类中方法的名称与参数进行识别，与返回值无关，换句话说不能通过返回值来判定两个方法是否相互构成重载
   范例
       正确范例

  public class MethodDemo {
    public static void fn(int a) {
        //方法体
    }
    public static int fn(double a) {
        //方法体
    }
}

public class MethodDemo {
    public static float fn(int a) {
        //方法体
    }
    public static int fn(int a , int b) {
        //方法体
    }
}

错误范例

 public class MethodDemo {
    public static void fn(int a) {
        //方法体
    }
    public static int fn(int a) {     /*错误原因：重载与返回值无关*/
        //方法体
    }
}

public class MethodDemo01 {
    public static void fn(int a) {
        //方法体
    }
} 
public class MethodDemo02 {
    public static int fn(double a) { /*错误原因：这是两个类的两个fn方法*/
        //方法体
    }
}

6.方法的参数传递

1.方法参数传递基本类型
       结论
           基本数据类型的参数，形式参数的改变，不影响实际参数
       结论依据
           每个方法在栈内存中，都会有独立的栈空间，方法运行结束后就会弹栈消失

   2方法参数传递引用类型
       结论
           对于引用类型的参数，形式参数的改变，影响实际参数的值
       结论依据
           引用数据类型的传参，传入的是地址值，内存中会造成两个引用指向同一个内存的效果，所以即使方法弹栈，堆内存中的数据也已经是改变后的结果。

7.方法的注意事项

   1.方法不能嵌套定义
   2.void表示无返回值，可以省略return，也可以单独的书写return，后面不加数据
范例

 public class MethodDemo {
    public static void main(String[] args) {

    }
    public static void methodTwo() {
        //return 100; 编译错误，因为没有具体返回值类型
        return;    
        //System.out.println(100); return语句后面不能跟数据或代码
    }
}

总结

以上就是我对数组和方法的学习的部分反馈，有不足的地方欢迎大家互相指正

Biegral Blog

数组与方法

前言

一、数组

1.什么是数组

2.如何定义数组

3.数组初始化