Java学习Day3

快来打我* 2023-02-23 12:26 2阅读 0赞

# 函数 #

## 函数的重载 ##

在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\]);**  
![在这里插入图片描述][20200707220824859.png]  
// 异常：是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}};

![在这里插入图片描述][20200707234431251.png]

**遍历数组**  
// 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;	
    		}

[20200707220824859.png]: https://img-blog.csdnimg.cn/20200707220824859.png
[20200707234431251.png]: https://img-blog.csdnimg.cn/20200707234431251.png