Java数组和方法

一、数组

1.定义：数组(array)是一种用于存储多个相同类型数据的存储模型。

格式1：数据类型[] 变量名（推荐使用）

例子： int[ ] arr

定义了一个int类型数组，数组名是arr

格式2：数据类型变量名[ ]

例子： int arr[ ]

定义了一个int类型变量，变量名是arr数组

2.数组初始化

初始化：就是为数组中的数组元素分配内存空间，

并为每个数组元素赋值

动态初始化：初始化时只指定数组长度，

由系统为数组分配初始值

格式：数组类型[ ] 变量名= new 数组类型[数组长度];

例子：int[ ] arr=new int[3];

new为数组申请内存空间

3.数组元素的访问

数组变量访问方式

格式：数组名

数组内部保存的数据的访问方式

格式：数组名[索引]

索引是数组中数据的编号方式

作用：索引用于访问数组中的数据使用，数组名[索引]等同于变量名，是一种特殊的变量名

特征：索引是从0开始、连续的、逐一增加（每次加1）

4.内存分配

int[ ] arr=new int[3];

（1）栈内存：存储局部变量

        定义在方法中的变量，例如：arr

        使用完毕立即消失

（2）堆内存：存储new出来的内容(实体，对象)

        数组在初始化时，会为存储空间添加默认值

整数：默认值 0

浮点数：默认值 0.0

布尔值：默认值 false

字符：默认空字符

引用数据类型：默认值 null

每一个new出来的东西都有一个地址值，使用完毕，

会在垃圾回收器空闲时被回收

多个数组指向相同，一个改变，其他跟着改变。

5.数组静态初始化

静态初始化：初始化时指定每个数组元素的初始值，

由系统决定数组长度

格式：数据类型[ ] 变量名= new 数据类型[ ]{数据1，数据2，数据3，......};

例子：int[ ] arr=new int[ ]{1,2,3};

简化格式：数据类型[ ] 变量名={数据1，数据2，数据3，......};

例子：int[ ] arr={1,2,3};

6.数组操作常见小问题

a.索引越界：访问了数组中不存在的索引对应的元素，

造成索引越界问题

int[ ] arr=new int[3];

System.out.println(arr[3]);→ArrayIndexOutOfBoundsException

b.空指针异常：arr=null；把null赋给数组，访问的数组已经

不再指向堆内存数据，造成空指针异常

c.null：空值，引用数据类型的默认值，表示不指向任何有效对象

arr=null;

System.out.println(arr[0]);→NullPointerException

7.数组常见操作

（1）遍历:获取数组中的每一个元素输出在控制台

获取数组元素：数组名.length

for(int x=0; x<arr.length; x++){

System.out.println(arr[x]);

}

（2）获取最值

int[ ] arr={12,45,98,73,68};int max=arr[0]; //定义一个变量，用于保存最大值，取数组中第一个数据作为初始值for(int x=1;x<arr.length;x++){  if(arr[x]>max){max=arr[x]; //与数组中剩余的数据逐个对比，每次比对将最大值保存到变量中} }System.out.println("max:"+max)；

8.二维数组

语法: 类型[][] 数组名=new 类型[大小][大小]

例如: int a[][]=new int[2][3]

public class TwoDimensionalArray02 { 
//编写一个 main 方法 public static void main(String[] args) { //int arr[][] = new int[2][3]; int arr[][]; //声明二维数组 arr = new int[2][3];//再开空间 arr[1][1] = 8; //遍历 arr 数组 for(int i = 0; i < arr.length; i++) { for(int j = 0; j < arr[i].length; j++) {//对每个一维数组遍历 System.out.print(arr[i][j] +" "); }System.out.println();//换行 } }
}

(1) 动态初始化

      先声明：类型数组名[][];

       再定义 (开辟空间) 数组名 = new 类型[大小][大小]

      赋值 (有默认值，比如 int 类型的就是 0)

public class TwoDimensionalArray03 {public static void main(String[] args) {//创建 二维数组，一个有 3 个一维数组，但是每个一维数组还没有开数据空间 int[][] arr = new int[3][]; for(int i = 0; i < arr.length; i++) {//遍历 arr 每个一维数组 //给每个一维数组开空间 new //如果没有给一维数组 new ,那么 arr[i]就是 null arr[i] = new int[i + 1]; //遍历一维数组，并给一维数组的每个元素赋值 for(int j = 0; j < arr[i].length; j++) { arr[i][j] = i + 1;//赋值 }}System.out.println("=====arr 元素====="); //遍历 arr 输出 for(int i = 0; i < arr.length; i++) { //输出 arr 的每个一维数组 for(int j = 0; j < arr[i].length; j++) { System.out.print(arr[i][j] + " "); }System.out.println();//换行 } } 
}

(2) 静态初始化

定义类型数组名[][] = {{值 1,值 2..},{值 1,值 2..},{值 1,值 2..}}

比如: int [][] arr = {{1,1,1}, {8,8,9}, {100}};

public class TwoDimensionalArray05 { //编写一个 main 方法 public static void main(String[] args) { int arr[][]= {{4,6},{1,4,5,7},{-2}};int sum = 0; for(int i = 0; i < arr.length; i++) { //遍历每个一维数组 for(int j = 0; j < arr[i].length; j++) { sum += arr[i][j];} }System.out.println("sum=" + sum); } 
}

二、方法

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

注意：

方法定义：方法必须先创建再使用

方法调用：创建后并不是直接运行的，需要手动使用后才执行

1.方法的定义和调用

(1)方法定义格式：

public static void 方法名(){

//方法体

}

例子： public static void isEvenNumber(){

//方法体

}

(2)方法调用格式：方法名();

例子：isEvenNumber();

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

public class MethodDemo{public static void main(String[ ] args){isEvenNumber();}//定义一个变量，判断该数据是否是偶数public static void isEvenNumber(){int number=10;if(number%2==0){System.out.println(true);}else{System.out.println(false);}}}

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

(1) 带参数方法定义

格式： public static void 方法名 (参数) {... ...}

格式 (单个参数)： public static void 方法名 (数据类型变量名) {... ...}

范例 (单个参数)： public static void isEvenNumber (int number) {... ...}

格式 (多个参数)： public static void 方法名 (数据类型变量名1，数据类型变量名2) {... ...}

范例 (多个参数)： public static void getMax (int number1，int number2) {... ...}

注意：

方法定义时，参数中的数据类型和变量名都不能缺少，缺少任意一个程序将报错。

方法定义时，多个参数之间使用逗号(,)分隔。

(2) 带参数方法调用

格式：方法名(参数)；

格式 (单个参数)：方法名 (变量名/常量值)；

范例 (单个参数)： isEvenNumber (5)；

格式 (多个参数)：方法名 (变量名1/常量值1，变量名2/常量值2)；

范例 (多个参数)： getMax (5，6)；

注意：

方法调用时，参数的数量和类型必须与方法定义中的设置相匹配，否则程序将报错。

public class MethodDemo{public static void main(String[] args){//常量值的调用isEvenNumber(10);//变量的调用int number=10；isEvenNumber(number);}//需求：定义一个方法，该方法接收一个参数，判断该数据是否是偶数public static void isEvenNumber(int number){if(number%2==0){System.out.println(true);}else{System.out.println(false);}}}

(3) 形参和实参

形参：方法定义中的参数

等同于变量定义格式，例如：int number

实参：方法调用中的参数

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

public class MethodTest{public static void main(String[] args){//在main()方法中调用定义好的方法 (使用常量)getMax(a:10,b:20);//调用方法的时候，人家要几个，你就给几个，人家要什么类型，你就给什么类型的//getMax(30);//getMax(10.0,20.0);//在main方法中调用定义好的方法(使用变量)int a=10;int b=20;getMax(a,b);}//定义一个方法，用于打印两个数字中的较大数，例如getMax()//为方法定义两个参数，用于接收两个数字public static void getMax（int a,int b）{//使用分支语句分两种情况对两个数字的大小关系进行处理if（a>b）{System.out.println(a);}else{System.out.println(b);}}}

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

(1) 带返回值方法的定义

格式：public static 数据类型方法名(参数){

return 数据；

}

范例1：public static boolean isEvenNumber(int number){

return true；

}

范例2：public static int getMax(int a，int b){

return 100；

}

注意：方法定义时return后面的返回值与方法定义上的数据类型要匹配，否则程序将报错

(2) 带返回值的调用

格式1: 方法名(参数)；

范例：isEvenNumber(5)；

格式2: 数据类型变量名=方法名(参数)；

范例：boolean flag= isEvenNumber(5)；

注意：方法的返回值通常会使用变量接收，否则该返回值将无意义

public class MethodTest{public static void main(String[] args){//1:方法名(参数)；//isEvenNumber(10);//true;//2.数据类型 变量名=方法名(参数)；boolean flag=isEvenNumber(10);//boolean flag=true;System.out.println(flag);}//定义一个方法，该方法接收一个参数，判断该数据是否是偶数，并返回真假值public static boolean isEvenNumber（int number）{//使用分支语句分两种情况对两个数字的大小关系进行处理if（number%2==0）{return true;}else{return false;}}}

public class MethodTest{public static void main(String[] args){//在main()方法中调用定义好的方法并使用变量保存(推荐使用)int result=getMax(a:10,b:20);System.out.println(result);//在main方法中调用定义好的方法并直接打印结果System.out.println(getMax(a:10,b:20));}//为方法定义两个参数，用于接收两个数字public static int getMax（int a,int b）{//使用分支语句分两种情况对两个数字的大小关系进行处理//根据题设分别设置两种情况下对应的返回结果if（a>b）{return a;}else{return b;}}}

4.方法的注意事项

a.方法不能嵌套定义

b.void表示无返回值，可以省略return，也可以单独的书写return，后面不加数据

5.方法的通用格式

格式：public static 返回值类型方法名(参数){

方法体；

return 数据；

}

定义方法时，要做到两个明确

明确返回值类型：主要是明确方法操作完毕之后是否有数据返回

如果没有，写void；如果有，写对应的数据类型

明确参数：主要是明确参数的类型和数量

调用方法时

void类型的方法，直接调用即可

非void类型的方法，推荐用变量接收调用

6.方法重载(OverLoad)

指同一个类中定义的多个方法之间的关系，满足下列条件的多个方法相互构成重载。

a. 多个方法在同一类中

b. 多个方法具有相同的方法名

c. 多个方法的参数不相同，类型不同或者数量不同

特点：

a.重载对应方法的定义，与方法的调用无关，调用方式参照标准格式

b.重载仅针对同一类中方法的名称与参数进行识别，与返回值无关，换句话说不能通过

返回值来判定两个方法是否构成重载

public class MethodDemo{public static void main(String[] args){//调用方法int result=sum(a;10,b:20);System.out.println(result);double result2=sum(a:10.0,b:20.0);System.out.println(result2);int return3=sum(a:10 b:20 c:30);System.out.println(result3);}//需求1：求两个int类型数据和的方法public static int sum(int a,int b){return a+b;}//需求2：求两个double类型数据和的方法public static double sum(double a,double b){return a+b;}//需求3：求三个int类型数据和的方法public static doublic sum(int a,int b,int c){return a+b+c;}
}

与返回值无关，在调用的时候，Java虚拟机会通过参数的不同来区分同名的方法。

public class MethodTest{public static void main(String[] args){//调用方法System.out.println(compare(10,20));System.out.println(compare((byte)10,(byte)20));System.out.println(compare((short)10,(short)20));System.out.println(compare(10L,20L));}//intpublic static boolean compare(int a,int b){System.out.println("int");return a==b;}//bytepublic static boolean compare(byte a,byte b){System.out.println("byte");return a==b;}//shortpublic static boolean compare(short a,short b){System.out.println("short");return a==b;}//longpublic static boolean compare(long a,long b){System.out.println("long");return a==b;}
}

7.方法的参数传递

(1) 基本类型

对于基本数据类型的参数，形式参数的改变，不影响实际参数的值

public class ArgsDemo01{public static void main(String[] args){int number=100;System.out.println("调用change方法前："+number);change(number);System.out.println("调用change方法后："+number);}public static void change(int number){number=200;}
}

(2) 引用类型

对于引用类型的参数，形式参数的改变，影响实际参数的值

public class ArgsDemo02{public static void main(String[] args){int[] arr={10,20,30};System.out.println("调用change方法前："+arr[1]);change(arr);System.out.println("调用change方法后："+arr[1]);}public static void change(int[] arr){arr[1]=200;}
}

public class MethodTest01{public ststic void main(String[] args){//定义一个数组，用静态初始化完成数组元素初始化int[] arr={11,22,33,44,55};//调用方法printArray(arr);}//定义一个方法，用数组遍历通用格式对数组进行遍历/*两个明确：返回值类型：void参数：int[] arr*//*public static void printArray(int[] arr){for(int x=0;x<arr.length;x++){System.out.println(arr[x]);}}*/public static void printArray(int[] arr){System.out.print("[");for(int x=0;x<arr.length;x++){if(x==arr.length-1){System.out.print(arr[x]);}else{System.out.print(arr[x]+", ");}}System.out.println("]");}
}

public class MethodTest02{public ststic void main(String[] args){//定义一个数组，用静态初始化完成数组元素初始化int[] arr={12,45,98,73,60};//调用获得最大值方法，用变量接收返回结果int number=getMax(arr);//把结果输出在控制台System.out.println("number:"+number);}//定义一个方法，用来获取数组中的最大值/*两个明确：返回值类型：int参数：int[] arr*/public static int getMax(int[] arr){int max=arr[0];for(int x=1;x<arr.length;x++){if(arr[x]>max){max=arr[x];}}return max;}
}

8.可变参数

java 允许将同一个类中多个同名同功能但参数个数不同的方法，封装成一个方法。

访问修饰符返回类型方法名(数据类型... 形参名) {

}

(1) 可变参数的实参可以为 0个或任意多个

(2) 可变参数的实参可以为数组

(3) 可变参数的本质就是数组

(4) 可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后

(5) 一个形参列表中只能出现一个可变参数

public class VarParameter01 { //编写一个 main 方法 public static void main(String[] args) { HspMethod m = new HspMethod(); System.out.println(m.sum(1, 5, 100)); //106 System.out.println(m.sum(1,19)); //20 } 
}class HspMethod {
//1. int... 表示接受的是可变参数，类型是 int ,即可以接收多个 int(0-多)
//2. 使用可变参数时，可以当做数组来使用 即 nums 可以当做数组
//3. 遍历 nums 求和即可 public int sum(int... nums) { //System.out.println("接收的参数个数=" + nums.length);int res = 0; for(int i = 0;i < nums.length; i++) { res += nums[i];}return res;} 
}