小白学习JavaSE-day04-方法与数组

一、方法（Method）

1、什么是方法

方法：它是一段独立可以被执行的代码，然后通过被调用执行。其中封装（包裹）相关的逻辑代码。

定义方法：

修饰符   返回值类型    方法名( 参数类型   变量名,参数类型  变量名, ....... )
{
    方法体
}

• 修饰符：限制方法如何被调用
• 返回值类型：当方法被调用之后，如果方法有具体的数据返回给调用者，这时返回值类型需要与返回的数据保持一致。如果没有任何数据返回，类型书写为void
• 方法名：合法的用户标识符，需要遵守小驼峰式命名（从第二个的单词开始首字母大写）
• 参数列表：如果方法被调用，需要调用者传递一定的数据到方法中，这时方法上就需要书写参数（与定义变量相同），如果不需要任何的数据，参数可以不写。
• 方法体：它是具体执行功能的代码。

方法代表的是是一个功能，如何才能根据需求写出符合要求的方法呢？

分析上面的代码会发现，定义方法的时候需要考虑两个访问问题：

1、返回值： 方法是被调用执行，也就是功能运行之后，要不要将运行的一些数据给调用者。

2、 参数：方法被调用的时候，要不要接受一些数据作为功能运行的数据。

总结：

如果定义方法需要将结果给调用者，那么就需要在方法中使用return语句，返回具体的数据，那么方法定义时的返回值类型就必须和被返回的数据类型一致。

如果定义的方法运行时需要调用者的数据，那么就需要在定义方法的时候在方法上定义参数，接收传递的数据。

要求：尽可能将不同的逻辑代码放到不同的方法中，而main作为程序的调用和入口。

二、方法的重载

方法重载：在 同一个类 中 ， 出现了 同名的方法 ，但是 参数列表不同 ， 与返回值类型没有关系。

解释：参数列表不同：

​ 1、参数个数不同

​ 2、参数的类型不同

切记：与参数的变量名无关。

/*
 * 	需求：定义方法计算2个数的和，3个数的和
 */
public class Demo4 {
	
	public static void main(String[] args) {
		int s = getSum( 11 , 22 );
		int s2 = getSum( 11 , 22 , 33 );
		System.out.println(s);
		System.out.println(s2);
	}
	//	计算2个int类型数据的和值
	public static int getSum( int a , int b ) {
		return a + b;
	}
	//	计算3个int类型数据的和值
	public static int getSum( int a , int b , int c ) {
		return a + b + c;
	}
	
}

2.1、什么时候使用方法重载

在定义类的时候，类中需要多个方法完成类似的功能，但是方法接受的参数（个数、类型）不一致。

2.2、重载判断

void show( int a , float b , char c ){ }

下列哪些函数和给定函数可以在一个类中重载？

a.int show( int x , float y , char z ) 不行

b.void show( float b , int a , char c ) 可以，参数列表类型不同

c.void show( int c , float a , char b ) 不行

d.void show( int a , int b , int c ) 可以，参数列表类型不同

e.double show() 可以，参数个数不同

三、数组

1、什么是数组

变量：存储常量数据空间，但是某个时间点上只能存储一个常量。

如果程序中有很多的常量都需要存储，一个班级所有同学的年龄都需要存储，那么可以定义若干的变量，但是比较麻烦，那么可以借助Java中的数组来存储。

数组的定义：

**数据类型 [ ] 数组名 ; **

**数据类型 [ ] 数组名 = new 数据类型[ 长度 ] ; **

**数据类型 [ ] 数组名 = { 值, 值, 值, 值, 值, 值, 值, …… }; **

上面定义出来的数组被称为一维数组。

2、数组的定义

//	定义数组
int[] arr = new int[30];

在程序中定义一个数组，数组名为arr，数组共计有30个空间，每个空间都是int类型，每个空间都可以存放一个int类型的常量数据。

折半查找

• 前提一定要是有序序列

public class Demo5 {
	public static void main(String[] args) {
		
		int[] arr = {11, 33 ,44 ,55 , 66 ,88 , 99 , 101} ;
		int key = 12 ;
		int index = binarySearch( arr , key );
		System.out.println(index);
		
	}
	public static int binarySearch( int[] arr , int key ) {
		//	定义三个下标
		int start = 0 ;
		int end = arr.length - 1;
		int mid = ( start + end ) / 2;
		while( start <= end ) {
			if( arr[mid] == key ) {
				return mid;
			}else if( arr[mid] < key ) {
				start = mid + 1;
			}else {
				end = mid - 1;
			}
			mid =  ( start + end ) / 2;
		}
		return -1;
	}
}

数组排序

排序算法：7种，常见的：选择和冒泡，JDK中内置的数组排序算法为快速排序。

public class Demo6 {
	public static void main(String[] args) {
		int[] arr = new int[8];
		randomNumberInToArray(arr);
		printArray(arr);
		selectSort(arr);
		printArray(arr);
		
	}
	/*
	 * 	选择排序
	 */
	public static void selectSort( int[] arr ) {
		//	外循环提供的是需要被选中的空间的下标
		for (int i = 0; i < arr.length - 1; i++) {
			//	内循环提供是外循环后面空间剩余的所有下标
			for (int j = i + 1 ; j < arr.length; j++) {
				if( arr[i] < arr[j] ) {
					int tmp = arr[i];
					arr[i] = arr[j];
					arr[j] = tmp;
				}
			}
		}
		
	}
	/*
	 *	冒泡排序
	 */
	public static void bubbleSort( int[] arr ) {
		
		for( int i = 0 ; i < arr.length ; i++ ) {
			for(  int j = 0 ; j < arr.length -1 - i ; j++ ) {
				if( arr[j] < arr[j+1] ) {
					int tmp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = tmp;
				}
			}
		}
		
	}
	
	/*
	 * 	打印数组中的数据
	 */
	public static void printArray(int[] arr) {
		for (int i = 0; i < arr.length; i++) {
			System.out.print( arr[i] + " " );
		}
		System.out.println();
	}

	/*
	 * 	给指定的数组中存放随机数
	 */
	public static void randomNumberInToArray(int[] arr) {
		Random r = new Random();
		//	遍历数组，给每个空间中存放随机数
		for (int i = 0; i < arr.length; i++) {
			//	产生的随机数
			int x = r.nextInt(100) + 1;
			//	存储到数组中
			arr[i] = x;
		}
	}
}