Java03：方法/重载/递归

方法

1 方法定义

修饰符 返回值类型 方法名称(参数类型 参数名称，…){
方法体
return 返回值
}
方法组成： 方法名， 返回值， 参数列表

public class Demo{
	public static void main(String[] args){
		sum(10, 20);     //单独调用
	}
	public static int sum(int a, int b){
		int result = a +b;
		return result;
	}
}

注意：
要区分形参实参

2 方法调用

1) 单独调用 //sum(10, 20);
2) 打印调用 //System.out.println(sum(10, 20));
3) 赋值调用 //a = sum(10,20);

public class Sum{
	public static void main(String[] args){
		System.out.println(getSum());
	}
	public static int getSum(){
		int sum=0;
		for(i=1; i<=100,i++){
		sum += i;
		}
		return sum;
	}
}

三要素：
1).返回值
2).方法名称
3).参数列表

public static void method(){
	return;       //错误写法 return 10;  void 没有返回值 
//return 也用来结束方法的执行
}

public static int getMax(int a, int b){
	if(a>b){
		return a;
	}else {
		return b;
	}
}

3 方法重载 (Overload)

方法名称相同，参数列表（类型，个数）不同，返回值不做要求
重载方法的调用：JVM通过方法的参数列表，调用不同的方法

方法重载与下列因素相关：
1）参数个数不同
2）参数类型不同
3）参数的多类型顺序不同

方法重载与下列因素无关：
1）与方法的返回值类型无关
2）与参数的名称无关

class Test {
 public static void main(String[] args){
	int a = 20;
	int b = 9;
	int ret = add(a,b);
	System.out.println("ret = " + ret);
	
	double a = 2.5;
	double b = 2.3;
	double ret1 = add(a,b);
	System.out.println("ret1 = " + ret1);

	double a = 2.6;
	double b = 9.3;
	double c = 9.2;
	double ret2 = add(a,b,c);
	System.out.println("ret2 = " + ret2);
}
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;
}
}

3 方法递归

递归：方法调用自身的过程
递：每次递的时候，相当于开辟栈帧的过程，每递归一次，就会在栈上开辟一个内存。
归：每次在栈中取出相应的数据。

注：
在递归调用的过程当中系统为每一层的返回点、局部量等开辟了栈来存储。递归次数过多容易造成栈溢出等。

1. 递归求N的阶乘：

public static void main(String[] args){
	int n=4;
	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);
}

2) 递归求解斐波那契数列的第n项

public static int fib(int n){
	if(n==1 || n==2){
		return 1;
	}
	return fib(n-1)+fib(n-2)
}

fib(3)重复了3千万次
使用循环的方式来求斐波那契数列，避免出现冗余运算。

public static int fib(int n){
	int last2 = 1;
	int last1 =1;
	int cur = 0;
	for (int i=3; i<=n; i++){
		cur = last1 +last2;
		last2 = last1;
		last1 = cur;
	}
	return cur;
}

注意：

• 对于递归和循环都可以解决的问题，推荐使用循环，循环相对于递归更加高效。
• 递归的最后一次为终点不再调用自身，并以此作为起点开始往回返。