黑马程序员笔记（四）——函数和数组

最新推荐文章于 2023-10-04 20:40:41 发布

heshiyingx

最新推荐文章于 2023-10-04 20:40:41 发布

阅读量433

点赞数

分类专栏：黑马程序员——JAVA学习日记

本文链接：https://blog.csdn.net/heshiyingx/article/details/8665385

版权

黑马程序员——JAVA学习日记专栏收录该内容

21 篇文章 0 订阅

订阅专栏

------- android培训、 java培训、期待与您交流！ ----------

函数

一、函数的概述

1、 函数的定义：

函数就是定义在类中的具有特定功能的一段独立小程序。函数也称为方法。

2、 函数的意义：

在写程序时，操作不同数据使用的是同一种方法时，可以将这个方法定义成一个函数，这样避免了代码的重复，提

高了代码的复用性。

3、 函数的格式：

修饰符返回值类型函数名(参数类型形式参数1，参数类型形式参数2，)

{

执行语句;

return返回值;

}

返回值类型：函数运行后的结果的数据类型。

参数类型：是形式参数的数据类型。

形式参数：是一个变量，用于存储调用函数时传递给函数的实际参数。

实际参数：传递给形式参数的具体数值。

return：用于结束函数。

返回值：该值会返回给调用者。

注：当函数中没有值返回（如直接打印输出结果）时，返回值类型用void，并且可以省略return语句。

4、 函数的特点：

1)定义函数可以将功能代码进行封装

2)便于对该功能进行复用

3)函数只有被调用才会被执行

4)函数的出现提高了代码的复用性

5)对于函数没有具体返回值的情况，返回值类型用关键字void表示，那么该函数中的return语句如果在最后一行可以省略不写。

注：函数中只能调用函数，不可以在函数内部定义函数。定义函数时，函数的结果应该返回给调用者，交由调用者处理。

二、函数的应用

1、 如何定义函数:

①明确该功能运算完的结果是什么类型。

②明确是否需要传递参数参与运算。

三、函数的重载

1、定义：

在同一个类中，允许存在一个以上的同名函数，只要它们的参数个数或者参数类型不同即可。

2、重载的特点：与返回值类型无关，只看参数列表

3、重载的好处：方便于阅读，优化了程序设计

4、重载使用的场合：

当定义的功能相同，但参与运算的未知内容不同。此时只定义一个函数名称，通过参数列表来区分。

注：函数的参数是有顺序的，顺序不同也算重载，重载和返回值类型没关系。虚拟机会根据参数列表自动匹配想对象的函数。

(代码诠释) OverLoadedFunctionDemo

/*
	需求：定义一个函数实现两个或三个整数（int类型）的比较，将较大的值打印输出。
		  通过本例来理解函数重载的定义
	步骤：①明确该功能运算完的结果是什么类型：
				直接打印结果，所以无结果返回 用void修饰
		  ②明确是否需要传递参数参与运算。
				进行数据比较，需要调用者传递参数。

*/
class OverLoadedFunctionDemo 
{
	public static void compare(int x,int y)	
	/*
		自定义函数实现比较功能，因为是在主函数（静态）中调用，所以要用static修饰。
	*/
	{
		int z = (x>y)?x:y;
		System.out.println(x+"和"+y+"中，比较大的数字是"+z);
	}

	public static void compare(int x,int y,int m)
	{
		if (x>y && x>m)
			System.out.println(x+"和"+y+"和"+m+"中最大的数是"+x);
		else if (y>x && y>m)
			System.out.println(x+"和"+y+"和"+m+"中最大的数是"+y);
		else if (m>x && m>y)
			System.out.println(x+"和"+y+"和"+m+"中最大的数是"+m);
	}


	public static void main(String[] args) //主函数
	{
		compare(6,9);	//调用compare函数,虚拟机会根据参数列表自动匹配想对象的函数。
		compare(88,66,99);
	}
}
/*
运行结果
========================================
6和9中，比较大的数字是9
88和66和99中最大的数是99
========================================
*/

数组

一、数组（概述—内存结构）

1、定义：同一种类型数据的集合。其实数组就是一个容器。

2、数组的好处：可以自动给数组中的元素从0开始编号，方便操作这些元素。

3、格式：

①元素类型[]数组名 = new元素类型[元素个数或数组长度];

eg: int[] arr = new int[3];

②元素类型[]数组名 = new 元素类型[]{元素，元素，……};

注：此格式在明确数组内容时使用。

eg:int[] arr1 = new int[]{1,3,45,5,6,7};

int[] arr2 = new int{1,3,45,5,6,7} ;

③元素类型[] 数组名 = {元素,元素, 元素,元素, ……}

4、数组在内存中的存贮：

(1)堆：①存放用new产生的数据。

② 当引用该数组的变量执行变量名=null 该数组为垃圾值，由虚拟机启动垃圾回收机制进行回收。

注：堆内的数据都有默认的初始值。（int是0,double是0.0，long是0.0，boolean是false）

如： int[] arr1 = new int[3];中开辟的三个空间

(2)栈：①存放基本类型的数据和对象的引用，但对象本身不存放在栈中，而是存放在堆中。（数据使用完，会自动释放）

如:int[] arr1 = new int[3];中的arr1，它保存的是那个三个空间的首地址。称为arr1引用了int[3]数组。

二、数组（静态初始化——常见问题）

1、数组的初始化:

静态初始化：创建一个数组实体，并赋值。eg: int[] arr = new []{1,3,4,6,8};

默认初始化：只创建数组实体，不赋值。此时会自动赋默认值。

eg: int[] arr1 = new int[3];

2、常见问题：

①ArrayIndexOutOfBoundsException:角标越界，访问到了数组中不存在的角标。

eg:int[] arr = new int[2];

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

②NullPointerException:空指针异常：当引用没有任何指向值为null的情况，该引用还在用于操作实体。

eg: int[] arr = null;

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

四、二维数组

格式1：int[][] arr = new int[3][2];

u 定义了名称为arr的二维数组

二维数组中有3个一维数组
每一个一维数组中有2个元素
一维数组的名称分别为arr[0], arr[1], arr[2]
给第一个一维数组1脚标位赋值为78写法是：arr[0][1] = 78

格式2：int[][] arr = new int[3][];

二维数组中有3个一维数组
每个一维数组都是默认初始化值null
可以对这个三个一维数组分别进行初始化

格式3：int[][] arr = {{3,8,2},{2,7},{9,0,1,6}};

定义一个名称为arr的二维数组
二维数组中的有三个一维数组
每一个一维数组中具体元素也都已初始化
第一个一维数组 arr[0] = {3,8,2};
第二个一维数组 arr[1] = {2,7};
第三个一维数组 arr[2] = {9,0,1,6};
第三个一维数组的长度表示方式：arr[2].length;

五、数组的常见操作(通过函数调用来说明)

1、获取数组中的值以及求和：遍历

可通过for循环获取

数组名.length可获取该数组的长度。

2、求数组中的最大值(通过函数实现)：排序

a) 选择排序

b) 冒泡排序

3、查找：折半查找

(代码诠释) OperateArr

   /*
	 数组的工具类
*/

class ArrTool
{
	//获取最小值的功能
	public static int getMin(int[] arr)
	{
		int min = 0;

		for (int i=1; i<arr.length-1; ++i)
		{
			if (arr[i]<arr[min])
			{
				min =i;
			}
		}
		return arr[min];
	}

	//获取最大值的功能   
	public static int getMax(int[] arr)
	{
		int max = 0;
		
		for (int i=1; i<arr.length; ++i)
		{
			if (arr[max]<arr[i])
			{
				max = i;
			}
		}
		return arr[max];
	}

	//将数组进行从大到小的排列  选择排序
	public static int[] sortMax(int[] arr)
	{
		for (int i=0;i<arr.length-1 ;++i )
		{
			for(int m=i+1;m<arr.length;++m)
			{
				if (arr[i]<arr[m])
				{
					swap(arr,i,m);
				}
				
			}
		}
		return arr;
	}

	//将数组从小到大排列        冒泡排序
	public static int[] sortMin(int[]arr)
	{
		for (int i=0; i<arr.length-1;++i )
		{
			for (int m=0; m<arr.length-i-1;++m)
			{
				if (arr[m]>arr[m+1])
				{
					swap(arr,m,m+1);
				}
			}
		}
		return arr;
	}

	//将数组输出
	public static void print(String s,int[] arr)
	{
		System.out.print(s+"arr = {");
		for (int i=0; i<arr.length; ++i)
		{
			if (i != arr.length-1)
			{
				System.out.print(arr[i]+" ");
			}
			if (i==arr.length-1)
			{
				System.out.print(arr[i]+"}"+"\n");
			}
		}
	}


	public static void print(String s,int x)
	{
		System.out.print(s+x+"\n");	
	}

	//将两个数进行交换
	public static void swap(int[] arr,int x,int y)
	{

		int temp = arr[x];
		arr[x] = arr[y];
		arr[y] = temp;
		
	}

	//折半查找
	public static int halfSearch(int[] arr,int key)
	{
		int min = 0,max = arr.length-1,mid;

		while(min<=max)
		{
			mid = (max+min)>>1;

			if(key>arr[mid])
				min = mid + 1;
			else if(key<arr[mid])
				max = mid - 1;
			else
				return mid;
		}
		return -1;
	}

}

class OperateArr			//主函数
{
	public static void main(String[] args)
	{
		int[] arr = {89,2,8,56,4,7,36,99,66};
		int x = 36;
		
		ArrTool.print("最小值是",ArrTool.getMin(arr));  //调用工具类中的获取最小值的函数，并打印
		ArrTool.print("最大值是",ArrTool.getMax(arr));//调用工具类中的获取最大值的函数，并打印
		ArrTool.print("原数组是",arr);					//调用工具类中的打印函数
		ArrTool.print("从小到大排序是",ArrTool.sortMin(arr));	//调用工具类中的从小到大排序的函数，并打印
		ArrTool.print("从大到小排序是",ArrTool.sortMax(arr));	//调用工具类中的从大到小排序的函数，并打印
		ArrTool.print("在数组中与该数相匹配的元素的角标是",ArrTool.halfSearch(ArrTool.sortMin(arr),x));	//调用工具类中的折半查找的函数，并打印
	
	}
}
/*
执行结果
============================================
最小值是2
最大值是99
原数组是arr = {89 2 8 56 4 7 36 99 66}
从小到大排序是arr = {2 4 7 8 36 56 66 89 99}
从大到小排序是arr = {99 89 66 56 36 8 7 4 2}
在数组中与该数相匹配的元素的角标是4

============================================
*/