Java方法详解-优快云博客

本文深入解析了Java中的方法概念，包括方法的定义、调用、重载及递归使用。通过实例详细介绍了方法如何实现代码复用，提升代码的模块化和易读性。对比了递归与非递归实现斐波那契数列的效率，强调了适当选择算法的重要性。

1.1方法:实际上是一块代码片段,类似于c语言中的"函数".
在书写代码时使用方法的意义:
a.实现代码的复用,即一份代码可以在多个位置使用;
b.使代码简单易懂;
c.能够模块化的组织代码.

1.2方法定义语法:

//方法定义
public static 方法返回值 方法名称(参数类型 形参……){
方法体;
return 放回值;
}
//方法调用
返回值变量 = 方法名(实参……);

应用实例:

public class Test{
public static void main(String[] args){
int ret;
ret = add(1,2);  //方法调用
System.out.println(ret);
}
//方法的定义
public static int add(int x, int y){  
return x + y;
}
}

注意:
a.与c语言不同的是在java中没有"函数声明"这一概念;
b.方法可以没有参数,即参数列表可以为空;
c.方法可以没有返回值,在定义方法是将其返回值类型设为void,如上应用实例中的main方法;
d.方法既可以书写在调用位置的上方,也可以书写在调用位置的下方.

1.3方法的调用过程:
方法只有在被调用的时候才会执行,当代码被调用时,会将实参赋值给形参,参数传递完毕后,就会执行该方法体的代码,执行完毕后返回调用他的位置继续向下执行.
一个方法可以多次被调用:

public class Test{
public static void main(String[] args){
int ret;
ret = add(2,3);  //调用add方法
System.out.println("第一次调用方法 ret ="+ret);
ret = add(3,4);
System.out.println("第二次调用方法 ret ="+ret);
}
//定义add方法
public static int add(int x ,int y){
return x + y;
}
}

2.1方法重载:
方法重载是指多个方法享有相同的名字,但是这些方法的参数必须不同,或者是参数的个数不同,或者是参数类型不同.返回类型不能用来区分重载的方法.
a.Java的方法重载要求同名的方法必须有不同的参数表,仅有返回类型不同是不足以区分两个重载发方法的.
b.参数类型的区分度一定要足够,即参数类型,个数,顺序至少有一项不相同.
c.方法的修饰符可以不同.
应用实例:

public class Test{
public static void main(String[] args){
int a;
double b,c;
a = add(1,2);  //调用返回值是int型,且有两个参数是int型方法
System.out.println(a);  //输出3
b = add(2,3);   //调用返回值是double型,且有两个参数是double型方法
System.out.println(b);  //输出5.0
c = add(3,4,5);   //调用返回值是double型,且有三个参数是double型方法
System.out.println(c);  //输出12.0
}
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方法递归
方法递归是指一个方法在执行过程调用自身.
应用实例:
求5的阶乘:

public class Test{
public static void main(String[] args){
int n = 5;
System.out.println(factorial(5));  //调用递归求阶乘的方法,输出结果为120
}
//递归求阶乘的方法
public static int factorial(int n){
if (n == 1){
return 1;
}
return n * factorial(n - 1);  //递归调用自身
}
}

递归的过程如下:
先将参数向下递直到递归边界:

return 5 * factorial(4);
return 4 * factorial(3);
return 3 * factorial(2);
return 2 * factorial(1);
return 1.
遇到递归边界后,将返回方法的返回值:
6.return 1;
7.return 2 * 1;
8.return 3 * 2;
9.return 4 * 6;
10.return 5 * 24.
即方法的最终返回值为120.
对于可以不用递归解决的问题最好不用递归,这样可以提高效率.如下实例:
求第N个斐波那契数:
递归实现:

import java.util.Scanner;
public class Test {
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        System.out.println("请输入您想要的第N个斐波那契数中的N:");
        int n = in.nextInt();  //接收一个正整数
        System.out.println(fibonacci(n));  //调用找第N个斐波那契数方法
    }
    //找第N个斐波那契数方法
    public static long fibonacci(int n){
        if (n == 1 || n == 2){ //递归边界
            return 1;
        }
        return fibonacci(n - 1) + fibonacci(n - 2);  //递归调用方法自身
    }
}

非递归实现:

import java.util.Scanner;
public class Test {
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        System.out.println("请输入您想要的第N个斐波那契数中的N:");
        int n = in.nextInt();  //接收一个正整数
        System.out.println(noRecursionFibonacci(n));  //调用找第N个斐波那契数方法
    }
    //找第N个斐波那契数方法
    public static long noRecursionFibonacci(int n){
        long f1 = 1;  //第一项斐波那契数
        long f2 = 1;  //第二项斐波那契数
        if (n == 0){  
            return 0;
        }
        while (n > 2){  //从3项开始计算斐波那契数
            f2 = f1 + f2;  //某一项的斐波那契数是其前两项斐波那契数的和
            f1 = f2 - f1;  //f1的值更新为该项斐波那契数的前一项斐波那契数的值
            n--;  //斐波那契数从第3项开始逐步向第n项靠近
        }
        return f2;  //反回要找的第n项斐波那契数
    }
}

当n越大时,越能感觉到非递归实现的方法比递归实现的方法执行效率更高,这是因为递归过程中存在着大量的重复计算.