Java_Day4带参方法，数组

Day4

---

有参方法

方法定义：

修饰符 返回值类型 方法名 (参数列表，参数列表) {

​ 代码；

​ return 结果；

}

返回值类型：表示方法运行的结果，方法执行后将结果返回给调用者。

参列表：方法运行过程中的未知数据，调用者调用方法时传递

return: 表示就执行结果返回给我们的调用者，也表示我们方法的结束

定义方法有两个明确

定义一个方法实现两个整数和

需求：

**明确返回值类型：**方法计算整数和，结果必然是整数，返回值类型确定是int类型

返回return是带着返回值回到方法调用处(参数在哪里获取的)

**明确参数：**并不知道计算哪两个整数和，但是可以确定是两个整数，所以参数列表是两个int类型

int sum1 = add(1,5);//实参

方法：
int add(int a,int b){//形参
	int sum = a+b;
	return sum;
}
有省略

---

定义方法的三种格式

直接方法名调用；

格式：方法名（参数）

public class Demo {
	public static void main(String[] args) {
		add(1);//直接方法名调用
	}
	public static void add(int a){
        System.out.println(a);
	}
}

赋值调用，调用方法，在方法前面定义变量，接受方法的返回值

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

public class Demo {
	public static void main(String[] args) {
		int add = add(1, 5);//赋值给add再调用add
        System.out.println(add);
	}
	public static int add(int a,int b){
        int result = a+b;
		return result;
	}
}

打印调用

格式：输出语句中调用：System.out.println(方法名(参数))；

public class Demo {
	public static void main(String[] args) {
		System.out.println(add(1,3));//直接在输出语句中调用
	}
	public static int add(int a,int b){
		int result = a+b;
		return result;
	}
}

注意：输出语句调用方法，方法必须有返回值

定义一个方法，判断两个数是否相同

返回值类型：判断两个数，结果要么相同要么不同，可以定义为boolean

public static void main(String[] args) {
    System.out.println(equals(10,10));
}
public static boolean equals(int a, int b){
    boolean same;
	 /*if(a==b){
            same = true;
        }else{
            same = false;
        }*///第一个
    //boolean same = a==b ? ture:false;//2
    //boolean same = a ==b;//3
    /*return same;*///1,2,3
    return a == b;//4
}
//判断两个数是否相等的方法有很多

计算

/*练习一个计算1+2+‐‐‐‐+n的和（n为int就够）*/
public static int add(int n){
//存放我们和的变量
	int sum=0;
	for (int i = 1; i <=n ; i++) {
		sum+=i;
	}
    return sum;
}

定义方法的注意事项

1. 方法应该定义在类中，方法不能嵌套；
2. 方法定义的前后顺序无所谓；
3. 方法定义后要调用才能执行；
4. 如果方法有返回值，在方法最后必须写上retuen 返回值；
5. return后的返回值必须和方法的返回值类型对应；
6. 如果方法数据类型为void，则方法最后的return（也可以不写）不能有返回值。
7. 一个方法中可以有多个return，但是被执行的只能是一个。

---

方法的重载OverLoad

方法的重载：就是在一个类中，方法名一样，但是他们的参数列表不一样（与返回值、修饰符、参数名称无关）

参数列表不一样：个数不一样，数据类型不一样，顺序不一样

重载方法的底层：jvm通过方法的参数列表，去调用不同的方法

在调用输出语句时，println方法其实就是进行了多种数据类型的重载形式。

---

数组

数组的概念：数组是用于储存多个相同类型数据的集合。

数组的特点：

1. 数组是一种引用数据类型；
2. 数组当中的多个数据，类型必须统一
3. 数组的长度在运行期间不可变

定义和访问

定义数组

格式：

数组存储的数据类型[] 数组名字=new 数组存储的数据类型[数组的长度]

new:关键字，创建数据使用的关键字

int[] arr=new int[5];//动态初始化
//数据类型[] 数组名 = new 数据类型[数组长度]
//数组有特定长度，长度一旦指定，就不能更改

格式：

数据类型[ ] 数组名 = new 数据类型[ ]{ 元素1，元素2，……}

int[] arr=new int[]{1,2,3,4,5,6};//静态初始化

格式：数据类型[ ] 数组名 = { 元素1，元素2，……}

int[] arr={1,2,3,4,5,6};//静态初始化的省略格式

数组的访问

直接打印数组名称，得到的是数组相对应的：内存地址哈希值

所以要通过索引来打印数组内的值。

索引：每一个存储到数组的元素，都会自动拥有一个编号，从0开始直到数组的长度-1为止，这个自动编号成为数组的下标，可以通过数组的索引去访问我们数组中的元素

格式: 数组名[索引]

数组长度的特性：每一个数组都具有长度，而且是固定的，java中赋予了数组一个属性可以获取长度。语法：数组名.length,属性length的执行结果是数组的长度，由此可推断数组的最大索引值就是数组名.length-1。

int[] arr=new int[]{1,2,3,4,5,6};
int arr1=arr[0];
System.out.println(arr1);
System.out.println(arr.length);

注意：如果访问数组元素的时候，索引编号不存在，那么将发生数组索引越界异常

ArrayIndexOutOfBoundsException

如果给数组赋值了null但没有new创建，那么会发生空指针异常

NullPointerException

数组原理的内存图

内存概念：

内存是计算机中重要的原件，临时存储区域，作用就是运行程序，我们所编写的程序存放在硬盘中，但在硬盘中程序是不能运行的，必须放在内存中才能运行，运行完毕后会清除内存。

java虚拟机中的内存划分：

为了提高效率，对内存空间进行划分，每一个区域都有特定的处理数据的方式和内存管理方法。

jvm内存划分：

​ 寄存器：与CPU相关

​ 本地方法栈：jvm在使用操作系统功能的时候使用

​ 方法区：存储.class相关信息，包含方法的信息

​ 堆内存：存储对象或数组，new出来的都放在里面

​ 方法栈：方法运行时使用的内存，比如main运行时，进入方法栈

数据结构：

​ （栈：先进后出 队列：先进先出）

数组的内存图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bNzuROG2-1596120203426)(C:%5CUsers%5CAdministrator%5CAppData%5CRoaming%5CTypora%5Ctypora-user-images%5C1596118493903.png)]

---

数组遍历

数组中最大值获取：从数组中所有元素中找出最大值；

定义变量（存放最大值），保存数组0索引处的元素，遍历数组，获取数组中的每一个元素，将遍历的数组元素和保存数组0索引上的变量去比较，如果数组中元素的值大于变量值，把这个元素的值赋值给变量，直到遍历完成，得出最大值。

public class Demo {
	public static void main(String[] args) {
		int[] arr= {122,12,2324,4545,3,3434};
		//假设它是最大值
		int max=arr[0];
		for (int i = 0; i <arr.length ; i++) {
		//遍历数组中的元素和max比较
			if(arr[i]>max){
			//只记录最大值
				max=arr[i];
			}
		}
		System.out.println(max);
	}
}

练习

数组的反转：

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

思路：数组最远端的元素交换，实现反转，定义两个变量，保存数组的最

小索引和最大索引两个索引处的元素交换位置，最小索引++，最大索引–，

再次交换位置，直到我们的最小索引>最大索引，数组反转结束

public static void main(String[] args) {
	int[] arr={1,2,3,4,5,6};
	/** 循环中定义变量，min=0，最小索引
	*max=arr.length‐1,最大索引
	* min++，，，max‐‐* */
	for (int min=0,max=arr.length‐1;min <max; min++,max‐‐){
		int temp=arr[min];
		arr[min]=arr[max];
		arr[max]=temp;
	}
	for (int i = 0; i <arr.length ; i++) {
		System.out.print(arr[i]+"‐");
	}
}//老师的

public static void main(String[] args) {
//数组的反转：数组中元素颠倒顺序，例如原始数组为1,2,3,4,5.反转的数组为5,4,3,2,1
	int[] arr={1,2,3,4,5};
    for (int i = 0; i < arr.length/2; i++) {//因为交换数组内的元素，只用换数组长度一半次数
    	int temp = arr[i];
        arr[i] = arr[arr.length-1-i];
        arr[arr.length-1-i]=temp;
    }
    for (int i = 0; i <arr.length ; i++) {
        System.out.print(arr[i]+"  ");
    }
}//自己做的，差别不大

数组作为方法参数和返回值：

以前我们方法中有参数和方法返回值，但是使用的都是基本类型，那么我

们引用类型的数组作为我们的方法的参数应该怎么办。

1. 数组作为我们的参数去传递，传递的参数是数组的地址值。

2. 数组作为方法的返回值，返回的其实也是数组的地址值