【Java基础篇】方法的使用(方法的重载和递归)

简介: 【Java基础篇】方法的使用(方法的重载和递归)

1. 方法重载

1.1 方法重载的概念

在自然语言中,经常会出现“一词多义”的现象,比如:“好人”。

在自然语言中,一个词语如果有多重含义,那么就说该词语被重载了,具体代表什么含义需要结合具体的场景。

在Java中方法也是可以重载的。

在Java中,如果多个方法的名字相同,参数列表不同,则称该几种方法被重载了。


代码演示:

public class TestDemo {
    public static void main(String[] args) {
        add(1, 2);                // 调用add(int, int)
        add(1.5, 2.5);            // 调用add(double, double)
        add(1.5, 2.5, 3.5);       // 调用add(double, double, double)
    }
    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;
    }
}


注意:

  1. 方法名必须相同
  2. 参数列表必须不同(参数的个数不同、参数的类型不同、类型的次序必须不同)
  3. 与返回值类型是否相同无关

注意:两个方法如果仅仅只是因为返回值类型不同,是不能构成重载的

4. 编译器在编译代码时,会对实参类型进行推演,根据推演的结果来确定调用哪个方法


1.2 方法签名

在同一个作用域中不能定义两个相同名称的标识符。比如:方法中不能定义两个名字一样的变量,那为什么类中就可以定义方法名相同的方法呢?

方法签名即:经过编译器编译修改过之后方法最终的名字。具体方式:方法全路径名+参数列表+返回值类型,构成方法完整的名字。

public class TestDemo {
    public static int add(int x, int y){
        return x + y;
    }
    public static double add(double x, double y){
        return x + y;
    }
    public static void main(String[] args) {
        add(1,2);
        add(1.5, 2.5);
    }
}


上述代码经过编译之后,然后使用JDK自带的javap反汇编工具查看,具体操作:

  1. 先对工程进行编译生成.class字节码文件
  2. 在控制台中进入到要查看的.class所在的目录
  3. 输入:javap -v 字节码文件名字即可


方法签名中的一些特殊符号说明:

2. 递归

2.1 归的概念

一个方法在执行过程中调用自身, 就称为 “递归”.

递归相当于数学上的 “数学归纳法”, 有一个起始条件, 然后有一个递推公式.


例如, 我们求 N!


起始条件: N = 1 的时候, N! 为 1. 这个起始条件相当于递归的结束条件.


递归公式: 求 N! , 直接不好求, 可以把问题转换成 N! => N * (N-1)!


递归的必要条件:

  1. 将原问题划分成其子问题,注意:子问题必须要与原问题的解法相同
  2. 递归出口

代码示例: 递归求 N 的阶乘

public static void main(String[] args) {
    int n = 5;
    int ret = factor(n);
    System.out.println("ret = " + ret);
}
public static int factor(int n) {
    if (n == 1) {
        return 1;
   }
   int tmp = n * factor(n - 1);// factor 调用函数自身
    return tmp; 
}
// 执行结果
ret = 120


代码实现过程图:

递归:

递:绿色部分

递的过程相当于不断在栈上开辟空间,如下图:

归:红色部分,归的过程相当于不断在栈上把这些数据都拿走

2.2 递归执行过程分析

递归的程序的执行过程不太容易理解, 要想理解清楚递归, 必须先理解清楚 “方法的执行过程”, 尤其是 “方法执行结束之后, 回到调用位置继续往下执行”.

代码示例: 递归求 N 的阶乘

public static void main(String[] args) {
    int n = 5;
    int ret = factor(n);
    System.out.println("ret = " + ret);
}
public static int factor(int n) {
System.out.println("函数开始, n = " + n);
    if (n == 1) {
        System.out.println("函数结束, n = 1 ret = 1");
        return 1;
   }
    int ret = n * factor(n - 1);
    System.out.println("函数结束, n = " + n + " ret = " + ret);
    return ret;
}


执行结果


函数开始, n = 5


函数开始, n = 4


函数开始, n = 3


函数开始, n = 2


函数开始, n = 1


函数结束, n = 1 ret = 1


函数结束, n = 2 ret = 2


函数结束, n = 3 ret = 6


函数结束, n = 4 ret = 24


函数结束, n = 5 ret = 120


ret = 120


执行过程图

程序按照序号中标识的 (1) -> (8) 的顺序执行.

关于 “调用栈”


方法调用的时候, 会有一个 “栈” 这样的内存空间描述当前的调用关系. 称为调用栈.


每一次的方法调用就称为一个 “栈帧”, 每个栈帧中包含了这次调用的参数是哪些, 返回到哪里继续执行等信息。后面我们借助 IDEA 很容易看到调用栈的内容.


如果以后遇见下图中的问题,大概率是起始条件有问题


2.3 递归练习

代码示例1: 按顺序打印一个数字的每一位(例如 1234 打印出 1 2 3 4)

public class TestDemo {
    public static void print(int num) {
        if (num > 9) {
            print(num / 10);
        }
        System.out.println(num % 10);
    }
    public static void main(String[] args) {
        print(1234);
    }
}


代码流程图:

打印结果:

代码示例2: 递归求 1 + 2 + 3 + … + 10

public class TestDemo {
    public static int sum(int num) {
        if (num == 1) {
            return 1;
        }
      int tmp = num + sum(num - 1);
        return tmp;
    }
    public static void main(String[] args) {
        System.out.println(sum(10));
    }
}


输出结果:

代码示例3: 写一个递归方法,输入一个非负整数,返回组成它的数字之和. 例如,输入 1729, 则应该返回1+7+2+9,它的和是19

public class TestDemo {
    public static int sum(int num) {
        if (num < 10) {
            return num;
        }
        return num % 10 + sum(num / 10);
    }
    public static void main(String[] args) {
        System.out.println(sum(1729));
    }
}

打印结果显示:

代码示例4: 求斐波那契数列的第 N 项

斐波那契数是指这个数列从第3项开始,每一项都等于前两项之和。

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


我们求一下1,2,3,4,40的斐波那契数

public static void main(String[] args) {
        System.out.println(fib(1));
        System.out.println(fib(2));
        System.out.println(fib(3));
        System.out.println(fib(4));
        System.out.println(fib(40));
    }


运行结果:

当我们求 fib(40) 的时候发现,程序执行速度极慢,原因是进行了大量的重复运算。

所以:如果面试官让你写斐波那契数列,千万不要用递归写。 用递归写会非常的复杂,重复计算需要很久

我们可以用下面的代码计算一下执行了几次

//以40为例
public class TestDemo {
    public static int count = 0;
    public static int fib(int n) {
        if (n == 1) {
            count ++;
            return 0;
        }
        if (n == 2) {
            count ++;
            return 1;
        }
        return fib(n - 1) + fib(n - 2);
    }
    public static void main(String[] args) {
        System.out.println(fib(40));
        System.out.println(count);
    }
}


所以我们计算斐波那契数可以使用循环的方式来求斐波那契数列问题,避免出现冗余运算。

代码如下:

public class TestDemo {
    public static int fib(int n) {
        if (n == 1) {
            return 0;
        }
        if (n == 2) {
         return 1;
        }
        int f1 = 0;
        int f2 = 1;
        int f3 = -1;
        for (int i = 3; i <= n; i++) {
            f3 = f1 + f2;
            f1 = f2;
            f2 = f3;
        }
        return f3;
    }
    public static void main(String[] args) {
        System.out.println(fib(41));
    }
}


此时程序的执行效率大大提高了。

关于【Java基础篇】方法的使用(方法的重载和递归),七七就先分享到这里了,如果你认为这篇文章对你有帮助,请给七七点个赞吧,如果发现什么问题,欢迎评论区留言!!💕💕

目录
相关文章
|
5天前
|
Java 编译器
【Java开发指南 | 第十九篇】Java方法
【Java开发指南 | 第十九篇】Java方法
9 0
|
5天前
|
Java
java中递归实例
java中递归实例
19 0
|
1天前
|
并行计算 Java API
Java 8中的接口默认方法和静态方法以及并行数组
【5月更文挑战第19天】Java 8引入了许多新特性,其中包括接口的默认方法和静态方法,以及并行数组的能力。这些特性增强了Java的面向对象编程模型和数组处理能力。让我们深入了解它们的概念和实践。
19 2
|
1天前
|
Java 编译器
滚雪球学Java(34):探究Java方法的神奇魔法和参数传递奥秘
【5月更文挑战第9天】🏆本文收录于「滚雪球学Java」专栏,专业攻坚指数级提升,希望能够助你一臂之力,帮你早日登顶实现财富自由🚀;同时,欢迎大家关注&&收藏&&订阅!持续更新中,up!up!up!!
10 1
滚雪球学Java(34):探究Java方法的神奇魔法和参数传递奥秘
|
3天前
|
Java
Java中int[]与Integer[]相互转化的方法,java基础知识面试重点总结
Java中int[]与Integer[]相互转化的方法,java基础知识面试重点总结
|
5天前
|
Java
Java String 避免空指针的方法
Java String 避免空指针的方法
5 0
|
5天前
|
Java
【Java开发指南 | 第二十五篇】Java 重写(Override)与重载(Overload)
【Java开发指南 | 第二十五篇】Java 重写(Override)与重载(Overload)
12 1
|
5天前
|
Java 编译器
【Java开发指南 | 第十七篇】Java 方法
【Java开发指南 | 第十七篇】Java 方法
8 1
|
5天前
|
Java
【Java开发指南 | 第九篇】访问实例变量和方法、继承、接口
【Java开发指南 | 第九篇】访问实例变量和方法、继承、接口
14 4
|
5天前
|
XML JavaScript Java
详解Java解析XML的四种方法
详解Java解析XML的四种方法
16 1