Java学习Day3

函数

函数的重载

在JAVA中，可以在同一个类中存在多个函数，函数名称相同但参数列表不同。这就是函数的重载

抽象理解为：假如你是个木工，我要让你制作桌子（返回值）。然后，我给了你紫檀木，你就可以制作一张紫檀桌子；我给了你黄花梨，你可以做黄花梨的桌子。这些不同材质的木料，就是参数。返回的都是桌子，但是具体使用哪个函数，就根据传入的木料不同来决定的。
所以，可以根据所传递进来的不同参数，决定具体调用哪个函数。提高了函数使用的灵活性。

对于函数:java内部识别时,真正识别的是函数名字+参数类型的列表 例如: sum_int_float
* 函数的重载:在同一个类中,方法名相同,参数不相同的方法的关系
* 注意点:
* 1.参数的个数不同是重载
* 2.参数的类型不同是重载
* 3.参数的位置不同是重载
* 4.重载与返回值无关
* 5.重载与参数的名字无关
* 6.重载的方法本质上还是不同的方法.
* 7.重载的方法,方法名必须相同
* 作用:让一个名字可以有多个功能,最大的作用是用于构造方法.

			//第一个
			//求两个数的和
			public int sum(int a,int b) {//JVM内部识别的真正的函数名:sum_int_int
				return a+b;
			}
			//第二个  跟第一个是同一个函数,因为参数的名字不影响函数的类型
			public int sum(int c,int d) {//JVM内部识别的真正的函数名:sum_int_int
				return c+d;
			}
			//第三个:跟一是重载,参数的个数不同
			public int sum(int a,int b,int c) {//sum_int_int_int
				return a+b;
			}
			//第四个:跟一是重载,参数的类型不同
			public float sum(int a,float b) {
				return a+b;
			}
			//第五个:跟一不是重载,他的方法名和参数的类型都相同,但是返回值不同,所以叫错误
			public float sum(int a,int b) {
				return a+b;
			}
			
			//第六个:跟五和一都是重载,跟五的参数的位置不同,跟一参数类型不同
			public float sum(float a,int b) {
				return a+b;
			}

调用实例

public class Demo2 {

	public static void main(String[] args) {
		test1();
		}
		static void test1() {
			test2();
			System.out.print("a");
		}
		static void test2() {
			System.out.print("b");
			test5();
		}
		static void test3() {
			System.out.print("d");
			test4();
		}
		static void test4() {
			System.out.print("e");
		}
		static void test5() {
			test3();
			System.out.print("c");
		}
	}
//输出结果：bdeca

数组

一维数组

• 数组:是用来存储数据的
• 定义:可以同时存储多个相同类型的数据,它是引用数据类型.
• 数组是被放在堆区的.有默认值.
  构成:new + 数据类型 + [元素的个数]
  \\\\\\\ int[] arr = new int[3];
  new :在堆内开辟空间,将数组的地址返回
  int代表元素的数据类型
  [3]:代表数据的个数
• 我们可以通过一个变量保存数组的地址,这个变量的类型是int型的数组类型.
• 注意:int+[]是一个整体,代表一种数据类型,不能拆开.[]中也不能写数.
• 注意:数组的内存空间是连续的,并且空间创建之后是固定的.

比较简单数据类型和引用数据类型?

• 1.引用数据类型里面存储的是地址,并且这个地址是十六进制的数.简单数据类型存储的是值,是十进制的
  2.对于简单数据类型,直接在栈区的方法中开辟一块空间存储当前的变量,将要存储的数据直接放在这块空间里。

arr[0] = 3;
arr[1] = 4;
arr[2] = 5;
// 取值，赋值
// 存取值：根据下标存值
// 数组名[下标]
// 解释：先拿arr中保存的地址找到数组，然后再根据下标找到具体的元素，完成赋值或取值

异常处理System.out.println(arr[6]);

// 异常：是JAVA对程序出现的不正常情况的封装处理，得到的各种类
// 异常可以帮助我们更好的对错误进行查找，处理，改正
// 在打印的异常信息中包含异常的名字、原因、位置
// 名字 java.lang.ArrayIndexOutOfBoundsException：数组越界异常
// 原因：6，下标6超越了界限
// 位置：at com.git.Day5.Demo3.main(Demo3.java:42)

二维数组

	 * 一维数组:直接存储了一组数的数组
	 * 二维数组:直接存储的是多个一维数组(的地址)的数组
	 * 
	 * 数组的空间都是连续的,并且是固定的.
	 */
	
	//创建一维数组
	int[] arr = new int[3];
	//创建二维数组
	//组成:new + 数据类型+[一维数组的个数]+[每个一维数组中元素的个数]
	//注意点:第一个[]中的数不能省,第二个[]中的数可以省略.
	//写了,代表每个一维数组中元素的个数.不过这个数是一个估值.
	int[][] arr1 = new int[2][3];//这里元素是一维数组的地址,所以默认是null
	
	//通过下标存值取值
	arr[0] = 4;
	arr1[0] = new int[3];
	arr1[1] = new int[4];
	
	arr1[0][0] = 5;
	arr1[0][1] = 4;
	arr1[1][0] = 6;
	arr1[1][3] = 8;
	
	//遍历
	for (int i = 0; i < arr1.length; i++) {//获取二维数组的元素---一维数组
		for(int j=0;j<arr1[i].length;j++) {//对当前的一维数组进行遍历
			System.out.println(arr1[i][j]);
		}
	}
	
	//其他创建二维数组的方法
	int[][] arr2 = new int[][] {{2,3},{5,6,7}};
	int[][] arr3 = {{2,3},{5,6,7}};

遍历数组
// arr.lenth:数组元素的个数
1.使用for循环

		for (int i = 0; i < arr.length; i++) {
			System.out.println("value:"+arr[i]);
		}

2.使用增强for循环

		for(int i:arr) {
			System.out.println("i:"+i);
		}

	 * for(元素: 数组){
	 * 遍历
	 * }
	 * 原理：会自动从数组中取出元素，放入前面的元素中，当次遍历使用的就是这个元素
	 * 当这次遍历结束后，会自动从数组中取出第二个值，再次放入前面的元素（变量)中,依次进行
	 * 直到讲数组中的所有值取完，循环结束
	 */

创建数组的其他方式
1.new int[](这里什么都不写) {数组的元素} 这里的数量就是数组的个数
int[] arr1 =new int[] {3,4,5};

2.简化版
int[] arr2 = {3,4,5};

//可以直接将数组作为参数传递
run(new int[] {3,4,5});

//对于简化版的数组，不能直接当参数
run({3,4,5});

函数和数组的联合应用(值传递和地址传递)

Demo1

	public static void main(String[] args) {
		int[] arr1 = new int[] {3,5,7};
		getMax(arr1[0], arr1[1],arr1[2]);
		getMax(arr1);
		int value1 =  getMax(arr1);
		
		System.out.println(value1);
	}

	public static int getMax(int a,int b,int c) {//值传递：直接将简单数据类型作为参数
		int d = a>b?a:b;
		return d>c?d:c;
	}
	public static int getMax(int[] a) {//地址传递：直接将引用数据类型(地址)作为参数
		int temp =a[0];
		for(int i=1;i<a.length;i++) {
			if (temp<a[i]) {
				temp =a[i];
			}
			
		}return temp;
	}

Demo2

public static void main(String[] args) {
		/*
		 * 值传递:将保存简单数据的变量作为参数传递
		 * 址传递:将保存地址的变量作为参数传递
		 */
			//交换两个数的值
			int[] temp = {3,5};
			
			//地址传递
			jiaohuan(temp);
			System.out.println("temp[0]:"+temp[0]+"   temp[1]:"+temp[1]);//  5   3
			
			//值传递
			int[] temp1 = {3,5};
			jiaohuan(temp1[0], temp1[1]);
			System.out.println("temp1[0]:"+temp1[0]+"   temp1[1]:"+temp1[1]);//  3    5
	}
		//地址传递
		//对于地址传递，外部的函数的内部本质上操作是同一个数组，所以在函数内部进行值的交换，会影响外部值的改变
		public static void jiaohuan(int[] arr) {
			arr[0] = arr[0] ^ arr[1];
			arr[1] = arr[0] ^ arr[1];
			arr[0] = arr[0] ^ arr[1];	
		}
		//值传递
		//对于值传递，仅仅是对变量的值的改变，并没有影响原来的数组，所以原来的数组的值没有发生交换
		public static void jiaohuan(int a,int b) {
			a = a ^ b;
			b = a ^ b;
			a = a ^ b;	
		}