java中的方法

方法

一、方法的基本用法

1、什么是方法
方法就是一个代码片段，类似于C语言中的函数。
方法存在的意义：
1、当代码规模比较复杂的时候，是一种能够模块化的组织代码；
2、可实现代码的重复使用；
3、让代码更好理解更简单；
4、可直接调用现有方法。

2、方法的定义
基本语法：

//方法定义
public static 方法返回值 方法名称([参数类型 形参...]){
	方法体代码；
	[return 返回值]；
	}
//方法调用
返回值变量=方法名称(实参...)

注意：
1、方法定义时，可以没有参数但一定要指定参数类型；
2、方法定义时，如果没有返回值，则返回值类型应写为void;
3、方法定义时的参数称为形参，方法调用时的参数称为实参；
4、方法定义必须在类中；
5、java中没有像C语言中的“函数声明”。

3、方法调用的执行过程
基本规则
1、定义方法的时候, 不会执行方法的代码. 只有调用的时候才会执行；
2、当方法被调用的时候, 会将实参赋值给形参；
3、参数传递完毕后, 就会执行到方法体代码；
4、当方法执行完毕之后(遇到 return 语句)就执行完毕, 回到方法调用位置继续往下执行；
5、一个方法可被多次调用。
代码示例：计算1!+2!+3!+4!+5!

public class Test {
	public static void main(String[] args) {
		int sum = 0;
		for (int i = 1; i <= 5; i++) {
			sum += factor(i);
		}
	System.out.println("sum = " + sum);
	}
public static int factor(int n) {
System.out.println("计算 n 的阶乘中! n = " + n);
		int result = 1;
		for (int i = 1; i <= n; i++) {
			result *= i;
		}
	return result;
	}
}
// 执行结果
计算 n 的阶乘中! n = 1
计算 n 的阶乘中! n = 2
计算 n 的阶乘中! n = 3
计算 n 的阶乘中! n = 4
计算 n 的阶乘中! n = 5
sum = 153

4、实参和形参的关系（重点）
代码示例：交换两个整型变量

class Test {
	public static void main(String[] args) {
		int a = 10;
		int b = 20;
		swap(a, b);
		System.out.println("a = " + a + " b = " + b);
	}
public static void swap(int x, int y) {
	int tmp = x;
	x = y;
	y = tmp;
	}
}
// 运行结果
a = 10 b = 20

未实现原因分析：
对于基础类型来说，形参相当于对实参的拷贝，即传值调用；

解决办法：传引用类型参数（例如用数组来解决这个问题）

public class Test {
	public static void main(String[] args) {
		int[] arr = {10, 20};
		swap(arr);
		System.out.println("a = " + arr[0] + " b = " + arr[1]);
	}
public static void swap(int[] arr) {
	int tmp = arr[0];
	arr[0] = arr[1];
	arr[1] = tmp;
	}
}
// 运行结果
a = 20 b = 10

没有返回值的方法：方法返回值是可选的，在有些时候方法是可以没有返回值的，如上两个整型变量的交换。

二、方法的重载

 我们在需要用一个函数同时兼容多种参数的时候，可以使用方法的重载。
重载的规则：
 对于同一个类：
  1、方法名要相同
  2、方法的参数（参数个数或者参数类型）不同
  3、方法的返回值不影响重载

class Test {
	public static void main(String[] args) {
		int a = 10;
		int b = 20;
		int ret = add(a, b);
		System.out.println("ret = " + ret);
		double a2 = 10.5;
		double b2 = 20.5;
		double ret2 = add(a2, b2);
		System.out.println("ret2 = " + ret2);
		double a3 = 10.5;
		double b3 = 10.5;
		double c3 = 20.5;
		double ret3 = add(a3, b3, c3);
		System.out.println("ret3 = " + ret3);
	}
public static int add(int x, int y) {
	return x + y;
	}
public static double add(double x, double y) {
	return x + y;
	}
public static double add(double x, double y, double z) {
	return x + y + z;
	}
}

 上述代码中方法的名字都为add。但是有的add是计算int相加，有的add是计算double相加；有的计算两个数相加，有的是计算三个数相加。
 像这样的，同一个方法名字，提供不同的版本来实现就称为方法重载。

三、方法的递归

 递归的概念
一个方法在执行过程中调用自己本身，就称为递归。递归的作用，通俗来说就是将大问题化为小问题。
 递归的条件：
  1、调用自身
  2、有一个趋近于终止的条件
代码示例：
  用递归求N的阶乘

public static void main(String[] args) {
	int n = 5;
	int ret = factor(n);
	System.out.println("ret = " + ret);
	}
public static int factor(int n) {
	if (n == 1) {
	return 1;
	}
	return n * factor(n - 1); // factor 调用函数自身
}
// 执行结果
ret = 120

递归执行过程分析

 递归，顾名思义，两个动词，递和归，先递后归，在递的过程中遇到终止条件开始归。在上述例程中（n==1）为终止条件，当返回值为1时开始归。
 递归是一种重要的编程解决问题的方式。
 有些问题天然就是使用递归方式定义的（例如斐波那契数列，二叉树等），此时用递归来解决问题就会很容易；有些问题使用递归和非递归（迭代/循环）都可以解决，此时推荐使用非递归来实现，相比于递归，非递归程序更加高效，在递归中会进行大量的重复运算，大大降低了效率。