方法
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 方法递归
递归:方法调用自身的过程
递:每次递的时候,相当于开辟栈帧的过程,每递归一次,就会在栈上开辟一个内存。
归:每次在栈中取出相应的数据。
注:
在递归调用的过程当中系统为每一层的返回点、局部量等开辟了栈来存储。递归次数过多容易造成栈溢出等。
- 递归求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;
}
注意:
- 对于递归和循环都可以解决的问题,推荐使用循环,循环相对于递归更加高效。
- 递归的最后一次为终点不再调用自身,并以此作为起点开始往回返。