【Java】方法的使用-CSDN博客

本文链接：https://blog.csdn.net/m0_73883483/article/details/136440268

1.什么是方法?

1.1方法的定义

方法就是一段可重复调用的代码。（类似于函数）

定义一个语法的语法格式：

修饰符返回值类型方法名（参数类型参数名1，参数类型参数名2，...）{

执行语句；

...

return 返回值；

}

例题：判断一个年份是不是闰年

    public static boolean isLeapYear(int year){
        if(0 == year % 4 && 0 != year % 100 || 0 == year % 400){
            System.out.println(year + "是闰年");
            return true;
        }else {
            System.out.println(year + "不是闰年");
            return false;
        }
    }

解释：

修饰符：很多，例如：对访问权限进行限定的修饰符、static修饰符、final修饰符等。

返回值类型：用于限定方法的返回值类型。如果方法有返回值，返回值类型必须要与返回的实体类型相一致，如果没有返回值，则需要写void。

方法名：采用小驼峰命名法（第一个单词首字母小写，后面的单词首字母大写，例如:isLeapYear）。

参数列表：(参数类型参数名1，参数类型参数名2，...)参数列表用于描述方法在被调用时需要接收的参数，如果方法不需要接收任何参数，则参数列表为空，即（）内不写任何内容。参数为为形参。

返回值：被return语句返回的值，该值会返回给调用者。方法中return语句可以省略。

在Java当中，方法不能嵌套定义。方法必须写在类当中。也没有方法声明一说。

1.2方法调用的执行过程

方法的传参：

1.匹配参数的个数

2.匹配参数的类型

3.匹配参数的顺序

4.匹配返回值类型

    public static void main(String[] args) {
        int x = 1;
        int y = 2;
        int ret = add(x,y);
        System.out.println(ret);//x,y为实参
    }
    public static int add(int a,int b){//a,b为形参
        return a+b;
    }

解释：首先在栈上开辟一个main方法的栈帧，存储x和y，接着开辟一个add方法的栈帧，存储a和b，遇到return，把当前方法的栈帧从栈上销毁。当main方法执行结束之后，main方法的栈帧也会被销毁。

例题：求1-5的阶乘

    public static void main(String[] args) {
        int ret = facSum(5);
        System.out.println(ret);
    }
    //求一个数的阶乘
    public static int fac(int a) {
        int ret = 1;
        for (int i = 1; i <= a; i++) {
            ret *= i;
        }
        return ret;
    }
    //求阶乘和
    public static int facSum(int b){
        int sum = 0;
        for (int i = 1; i <=b ; i++) {
            sum+=fac(i);
        }
        return sum;
    }

方法的优点：可读性变高了，可重复使用了。

1.3实参和形参

形参只是拿到了实参的值。

在JAVA中，实参的值永远都是拷贝（赋值）到形参中，形参和实参本质上是两个实体。

例题：交换两个数。

public static void swap(int a,int b){
        int tmp = a;
        a = b;
        b = tmp;
    }
    public static void main(String[] args) {
        int x = 10;
        int y = 20;
        swap(x,y);
        System.out.println(x);
        System.out.println(y);
    }

//交换两个数,这样做java中交换不了，c语言中可以交换。为什么呢？

它只是完成了对a和b的交换，但没有完成x和y的交换。也就是说它只是把x和y的值传过去给了a和b，但是没有把地址传过去，所以这个方法没有办法交换两个数。

java当中是无法获取到局部变量的地址的。

2.方法的重载

同一个作用域内方法名相同但参数个数或者参数类型不同的方法。

1.方法名一样

2.方法的参数列表不一样【个数、数据类型、顺序】

3.返回值是否一样，不影响方法的重载

例题：

    //两个数相加
    public static void main(String[] args) {
        int x = 1;
        int y = 2;
        System.out.println(add(x,y));
        double num1 = 1.5;
        double num2 = 3.5;
        System.out.println(add(num1,num2));
    }
//类型不同：
    //int类型的两个数相加
    public static int add(int a,int b){
        return a+b;
    }
    //double类型的两个数相加
    public static double add(double a ,double b){
        return a+b;
    }
//顺序不同：
    public static long add(int a ,long b){
        return a+b;
    }
    public static long add(long a ,int b){
        return a+b;
    }
//个数不同：
    public static long add(int a ,long b，long c){
        return a+b+c;
    }
    public static long add(long a ,int b，long c){
        return a+b+c;
    }

3.递归

3.1递归的概念

一个方法在执行过程中自己调用自己。（有一个起始条件，然后有一个递推公式，不同的题，递推公式是不一样的）

    public static void fun(){
        fun();
    }
    public static void main(String[] args) {
        fun();
    }

StackOverflowError栈溢出错误（就是结束条件不对或者是结束条件没有）

3.2递归的调用过程

    public static void fun1(int a){
        if(a==1){
            return;
        }
        fun1(a-1);
    }
    public static void main(String[] args) {
        fun1(3);
    }

递归中使用的堆栈结构，称为“调用栈”，是一种存储调用信息的数据结构。每当递归函数调用到后，当前函数的栈帧会被压入调用栈中，包括函数的局部变量和参数。然后，递归函数调用本身，并将其栈帧压入调用栈中。当终止条件满足时，递归函数开始从调用栈中逐层弹出，并依次执行返回操作。

图解：

例题：递归求n的阶乘：

    //递归求n的阶乘
    public static int funfac(int n){
        if(n==1){
            return 1;
        }
        int tmp = n*funfac(n-1);
        return tmp;
    }

    public static void main(String[] args) {
        System.out.println(funfac(5));
    }