方法的定义

语句块

public class Test{
	public void main(String[] args){
	
	}
}

方法声明格式：

返回值类型 方法名(形式参数列数){
        Java语句;
}

方法的重载(overload)

public class TestOverload{
	public static void main(String[] args){
	}
	
	//求和的方法
	public static int add(int n1,int n2){
		int sum=n1+n2;
		return sum;
	}
	//方法名相同,参数个数不同,构成重载
	public static int add(int n1,int n2,int n3){
		int sum=n1+n2+n3;
		return sum;
	}
	//方法名相同，参数类型不同，构成重载
	public static double add(double n1,double n2){
		double sum=n1+n2;
		return sum;
	}
	
}	

不构成重载的情况

public static int add(int n1,int n2){
	int sum=n1+n2;
	return sum;
}
//编译错误:只有返回值不同,不构成方法的重载
public static double add(int n1,int n2){
	double sum=n1+n2;
	return sum;
}
//编译错误:只有参数名称不同,不构成方法的重载
public static int add(int n2,int n1){
	double sum=n1+n2;
	return sum;
}

递归算法详解

递归的基本思想:自己调用自己

public class TestRecursion{
	public static void main(String[] args){
		a();
	}
	static void a(){
		System.out.println("a");
		a();	//不断调用自己,直到占满内存
	}
	static void b(){
		System.out.println("b");
	}
}

递归结构包括两部分:
1.定义递归头。什么时候不调用自身方法。如果没有头,将陷入死循环
2.递归体。什么时候需要调用自身方法

//求阶乘的方法
static long factorial(int n){
	if(n==1){					//递归头
		return 1;
	}else{						//递归体。什么时候需要调用自身方法
		return n*factorial(n-1);//n!=n*(n-1)!
	}
}

迭代效率测试

public class TestRecursion{
	public static void main(String[] args){
		long d1=System.currentTimeMillis();
		System.out.printf("%d阶乘的结果:%s%n",10,factorial(10));
		long d2=System.currentTimeMillis();
		System.out.printf("递归费时:%s%n",d2-d1);	//耗时:32ms %n=\n
		
		factorialLoop(10);
	}
}

任何能用递归解决的问题也能使用迭代解决。
要求高性能的情况尽量避免使用递归,递归调用即花时间又耗内存。