Java基础之方法与数组

一、方法（函数）

1、什么是方法

Java的方法类似于其他语言的函数，是一段用来完成特定功能的代码片段，声明格式：

[修饰符1 修饰符2 ...]返回值类型 方法名（形式参数列表）{
     程序代码;
     [return 返回值;]
}

2、方法的参数列表既可以是有参数的，也可以是没有参数的

3、方法的好处：提高代码的重用性

4、说明：本篇涉及到的方法是由static修饰的静态变量

有参方法

带参方法的定义和无参方法一致，只是()中包含有一个或多个变量的定义，称为参数列表

参数有两种：

（1）形式参数（形参）：在方法定义时用于接收外界输入的数据。

（2）实际参数（实参）：调用方法时实际传给方法的数据。

方法参数的传递

1、如果传递的参数是基本数据类型，那么方法接收到的实际上是这个数据的值拷贝（值副本）。

2、如果传递的参数是引用类型，那么传过来的就是这个引用参数的副本，这个副本存放的是参数的地址。

方法返回值

两种情况

1、如果方法没有没有返回值，那么它的返回值类型是void

package basemethod;

public class ChangeNumber {
	public static void main(String[] args) {
		int a = 1;
		System.out.println("调用changeNumber(int a)方法之前，a=" + a);
		changeNumber(a);
		System.out.println("调用changeNumber(int a)方法之后，a=" + a);
	}
	
	public static void changeNumber(int a) {
		if(a == 3) {
			System.out.println("该方法直接结束！");
			return ;
		}
		System.out.println("进入changeNUmber(int a)方法...a=" + a);
		a += 5;
		System.out.println("在changeNumber(int a)方法改变值后，a=" + a);
	}
}

运行结果：

调用changeNumber(int a)方法之前，a=1
进入changeNUmber(int a)方法...a=1
在changeNumber(int a)方法改变值后，a=6
调用changeNumber(int a)方法之后，a=1

       这是一个没有返回值类型的方法，因此它的返回值类型是void

2、如果方法有返回值，方法中必须使用关键字return返回该值，返回值类型为该返回的值的类型

return 表达式;      //作用：跳出方法、返回结果

package basemethod;

import java.util.Scanner;

public class BaseMethod {
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		System.out.print("请输入基数：");
		int base = input.nextInt();//等待键盘输入
		System.out.print("请输入次数：");
		int count = input.nextInt();
		int sum = baseSum(base,count);
		System.out.println("计算结果是：" + sum);
		input.close();
	}
	
	/**
	 * 这个方法用来根据基数和次数计算和
	 * @param base 接收传递来的基数
	 * @param count 接收传递来的次数
	 * @return 返回计算结果
	 */
	public static int baseSum(int base,int count) {
		int number = 0;
		int sum = 0;
		for(int i = 0; i < count;i++) {
			number = number * 10 + base;//计算当前项的数据
			sum += number;
		}
		return sum;
	}
}

运行结果：

请输入基数：25
请输入次数：4

计算结果是：30850

      在上面这个实例中定义了一个有参方法baseSum(int base,int count),在这个定义的方法中base和count就是形式参数（形参），这两个参数会接收方法被调用时传递过来的数据，在main函数中调用了此方法，在调用此方法时给方法传递了两个参数，而传递的这两个参数就是实际参数，自定义的baseSum方法通过传递过来的参数进行数据计算，计算完毕后会根据关键字return将计算的结果返回给调用处，即sum来接收返回的结果。

如果在方法中直接写return，而没有返回值，则方法结束。

      当我们上面的无参函数中的a的值改为3之后，则会直接跳出函数

结果：

调用changeNumber(int a)方法之前，a=3
该方法直接结束！
调用changeNumber(int a)方法之后，a=3

方法的调用

Java语言中使用下述形式调用方法：

1、直接调用：方法名（实参列表）；

2、类名调用：类名.方法名（实参列表）；

3、对象调用：对象.方法名（实参列表）；（面向对象中会使用）

实参的数目、数据类型和次序必须和所调用的方法声明的形参列表匹配。

递归算法（递推与回归）

1、递归调用指的是方法执行过程中出现该方法本身的调用，即自己调用自己

2、递归算法的两个条件：

（1）递归出口（结束条件）

（2）逐层递推向出口逼近

实例：汉诺塔问题

       设有3个塔座（A、B、C），在一个塔座A上放64个大小不同的盘片，按大盘在下、小盘在上的顺序叠放着，现要借助于B塔，把这些盘片移到C塔上去，要求在移动的过程中，每个塔座上的盘片始终保持大盘在在下、小盘在上的参数形式，每次只能移动一个盘片。

算法思路：假设要将n个盘片按规定从A塔移至C塔，可分为3步完成

（1）把A塔上的n-1个盘片借助C塔移到B塔；

（2）把第n个盘片从A塔移到C塔

（3）把B塔上的n-1个盘片借助A塔移到C塔上

package recursive;

import java.util.Scanner;

public class Hanoi {
	
	public static int count = 0;//记录移动的次数
	
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		System.out.print("请输入圆盘个数："); 
		int m = input.nextInt();
		hanoi(m,'A','B','C');
		input.close();
	}
	
	public static void hanoi(int n,char x,char y,char z) {
		if(n == 1) {
			count++;
			System.out.println("第"+count+"次移动，从"+x+"塔移动到"+z+"塔");
		}else {
			hanoi(n-1,x,z,y);
			count++;
			System.out.println("第"+count+"次移动，从"+x+"塔移动到"+z+"塔");
			hanoi(n-1,y,x,z);
		}
	}
}

运行结果：
请输入圆盘个数：3
第1次移动，从A塔移动到C塔
第2次移动，从A塔移动到B塔
第3次移动，从C塔移动到B塔
第4次移动，从A塔移动到C塔
第5次移动，从B塔移动到A塔
第6次移动，从B塔移动到C塔
第7次移动，从A塔移动到C塔

二、数组

数组是一个变量，存储相同数据类型的一组数据。

声明一个变量就是在内存空间中划出一块合适的空间

声明一个数组就是在内存空间中划出一串连续的空间

数组的基本要素

标识符：数组的名称，用于区分不同的数组、

数组长度属性：length

元素下标：对数组元素进行编号，从0开始，数组中的每个元素都可以通过下标来访问

数组长度固定不变，避免数组越界

数组上的声明、分配空间、赋值

1、声明数组：告诉计算机数据类型是什么

声明数组的两种格式：

数组的元素类型   数组名[];          如：float boy[];

数组的元素类型   []  数组名；     如：char[] girl;

声明数组时不规定数组长度

2、分配空间（元素）：告诉计算机分配几个连续的空间

为数组分配元素的格式如下：

数组名 = new 数组元素类型[数组元素的个数];            如：boy = new float[4];

3、赋值（初始化）：向分配的空间中存放数据

如：boy[0] = 22;

一维数组的静态初始化

在声明数组时还可以直接指定数组的具体内容。

数据类型[] 数组名 = {初值0,初值1,...,初值n};

如：int[] score = {65,71,80,99};

遍历数组的方式一：

通过for循环获取数组元素的下标，然后遍历对应元素

如：

for(int i = 0; i < array.length;i++){
      //逐个遍历数组元素array[i]
}

遍历数组的方式二：

foreach输出

for(数据类型   变量名称 : 数组名称){

        ...

}

如：

for(int x : array){
    //x为当前正在遍历的数组元素
}

实例1：声明数组、为数组分配空间、赋值及遍历

package array;

public class ArrayDemo {
	public static void main(String[] args) {
		int[] a = new int[5];//声明数组并分配空间（元素）
		a[2] = 23;//给数组赋值（初始化）
		a[4] = 19;
		System.out.println("遍历第一个数组：");
		//使用第一种方式遍历数组
		for(int i = 0; i < a.length;i++) {
			System.out.print(a[i] + " ");
		}
		System.out.println();
		
		int[] b = {11,22,34,85,94};//直接给数组赋值
		System.out.println("遍历第二个数组：");
		//使用第二种方式遍历数组
		for(int x : b) {
			System.out.print(x + " ");
		}
		System.out.println();
	}
}

运行结果：

遍历第一个数组：
0 0 23 0 19 
遍历第二个数组：
11 22 34 85 94 

实例2：改变数组12,52,89,888,41中第三个元素的值为666

package array;

public class MethodArray {
	public static void main(String[] args) {
		int[] a = {12,52,89,888,41};
		System.out.println("数组元素改变之前：");
		for (int i = 0; i < a.length; i++) {
			System.out.print(a[i] + " ");
		}
		System.out.println();
		changeArray(a);
		System.out.println("数组元素改变之后：");
		for (int i = 0; i < a.length; i++) {
			System.out.print(a[i] + " ");
		}
	}
	
	public static void changeArray(int[] a) {
		a[2] = 666;
	}
}

运行结果：

数组元素改变之前：
12 52 89 888 41 
数组元素改变之后：
12 52 666 888 41 

补充：

方法的可变参数

在JDK1.5(JavaSE 5.0)之后，引入一个新概念：

可变参数，即：方法中可接收的参数不再是固定的，而是可以根据需要传递数量不等的参数个数。

可变参数的定义格式：

返回值类型   方法名称(类型...  参数名称){

}

注意：向方法传递可变参数后，参数在方法内部是以数组的形式保存下来的。

实例：

package array;

public class ChangeableParam {
	public static void main(String[] args) {
		show();
		show(1,3,5,7,9);
		show(2,4,6,8,0,12);
	}
	
	public static void show(int... a) {
		System.out.println("当前传递的参数个数是：" + a.length);
		for (int i = 0; i < a.length; i++) {
			System.out.print(a[i] + " ");
		}
		System.out.println();
		System.out.println("**************************");
	}
}

运行结果：

当前传递的参数个数是：0


**************************
当前传递的参数个数是：5
1 3 5 7 9 
**************************
当前传递的参数个数是：6
2 4 6 8 0 12 
**************************