JavaSE——方法、递归

YoLo♪

已于 2022-09-16 08:15:37 修改

阅读量411

点赞数 42

分类专栏： JavaSE零基础学习文章标签： java servlet 前端

于 2022-08-03 21:02:26 首次发布

本文链接：https://blog.csdn.net/chenchenchencl/article/details/126148051

版权

JavaSE零基础学习专栏收录该内容

64 篇文章 42 订阅

订阅专栏

作者：敲代码の流川枫

博客主页：流川枫的博客

专栏：和我一起学java

语录：Stay hungry stay foolish

工欲善其事必先利其器，给大家介绍一款超牛的斩获大厂offer利器——牛客网

点击免费注册和我一起刷题吧

文章目录

1. 方法

1.1方法的概念

方法就是一个代码片段. 类似于 C 语言中的 "函数"

方法的意义：

1. 是能够模块化的组织代码(当代码规模比较复杂的时候)

2. 做到代码被重复使用, 一份代码可以在多个位置使用

3. 让代码更好理解更简单

4. 直接调用现有方法开发, 不必重复造轮子

1.2 方法定义

格式：

方法定义

修饰符返回值类型方法名称([参数类型形参...]){

方法体代码;

[return返回值];

}

实现一个求闰年的方法：

public class Method{
    //方法定义
    public static boolean isLeapYear(int year){
        if((0==year%4&&0!=year%100)||0==year%400) {
            return true;
        }else{
            return false;
        }
    }
}

注意：

1. 修饰符：现阶段直接使用public static 固定搭配

2. 返回值类型：如果方法有返回值，返回值类型必须要与返回的实体类型一致，如果没有返回值，必须写成void

3. 方法名字：采用小驼峰命名

4. 参数列表：如果方法没有参数，()中什么都不写，如果有参数，需指定参数类型，多个参数之间使用逗号隔开

5. 方法体：方法内部要执行的语句

6. 在java当中，方法必须写在类当中

7. 在java当中，方法不能嵌套定义

8. 在java当中，没有方法声明一说

1.3 方法调用的执行过程

调用方法--->传递参数--->找到方法地址--->执行被调方法的方法体--->被调方法结束返回--->回到主调方法继续往下执行

定义方法的时候, 不会执行方法的代码. 只有调用的时候才会执行

一个方法可以被多次调用

1.4 方法的重载

为什么要方法重载？

方法重载是让类以统一的方式处理不同类型数据的一种手段

调用方法时通过传递给它们的不同个数和类型的参数来决定具体使用哪个方法，这就是多态性

在定义一个方法时，参数的类型就已经确定，当我们想用其他类型参数传给该方法时，就会出现不兼容的错误，转换会让数据丢失，因此用方法重载来解决这个问题

也可以定义不同的参数类型的函数使用，但是要提供许多不同的方法名，为了避免这些繁琐的问题的出现，方法重载起到了很重要的作用

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

注意：

1. 方法名必须相同

2. 参数列表必须不同(参数的个数不同、参数的类型不同、类型的次序必须不同)

3. 与返回值类型是否相同无关

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

2. 递归

2.1 什么是递归

递归，就是在运行的过程中调用自己

构成递归需具备的条件：
1. 子问题须与原始问题为同样的事，且更为简单；
2. 不能无限制地调用本身，须有个出口，化简为非递归状况处理

终止条件必须是在递归最开始的地方，不能把终止条件写在递归结束的位置，这样的话，递归永远退不出来了，就会出现堆栈溢出异常(StackOverflowError)

public void recursion(参数0) {
    if (终止条件) {
        return;
    }
    recursion(参数1);
}

2.2 递归实例

递归求 N 的阶乘

递推公式：N的阶乘用F(n)表示，那么F(n) = n * F(n-1);

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        int n=0;
        Scanner scanner=new Scanner(System.in);
        n= scanner.nextInt();
        System.out.println(fac(n));
    }
    public static int fac(int n){
        if(n==1){
            return 1;
        }
        else{
            return n*fac(n-1);
        }
    }
}

递归求和

F(n) 代表1到n的和，那么F(n) = n + F(n-1)的和

F(n-1)是1到n-1的和

public class Test {
    public static void main(String[] args) {
        int a=10;
        System.out.println(sum(a));
    }
    public static int sum(int a){
        if(a<1)
            return 0;
        return (a+sum(a-1));

    }
}

递归打印数字的每一位

假设用F(n) 代表要顺序打印n的每一位，如果n是一个1位数，直接输出，如果n是2位数以上。

如：

123 相当于先打印12的每一位，再打印3

12 相当于先打印1的每一位，再打印2

1 只有一位数，直接打印

依次回退打印完，每一位即可

public class Test {
    public static void main(String[] args) {
    int n=123456;
    everypos(n);
    }
    public static void everypos(int a){
        if(a<10){
            System.out.println(a);
        }
        else{
            everypos(a/10);
            System.out.println(a%10);
        }
    }
}

返回的数字之和

要计算123456的每一位，主要在于如何得到每一位。在前面的习题中我们知道，除10 ，模10.可以做到

在执行n=123456的时候，先执行everypos(123456/10)也就是everypos(12345)这个函数，等最后回来之后，才会把n=123456时候的n%10算完

public class Test {
    public static void main(String[] args) {
    int n=123456;
        System.out.println(everypos(n));
    }
    public static int everypos(int a){
        if(a<10){
            //System.out.println(a);
            return a;
        }
        else{
           return  everypos(a/10)+a%10;
        }
    }
}

递归求斐波那契数列的第 N 项

F(n) 代表第n项斐波那契数列的值，那么F(n) = F(n-1) + F(n-2)的和

public class Test {
    public static void main(String[] args) {
        System.out.println(fib(3));
    }
    public static int fib(int n){
        if(n==1||n==2){
            return 1;
        }
        else{
            return fib(n-1)+fib(n-2);
        }
    }
}

递归求解汉诺塔问题

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

        Hanio(4,'A','B','C');
    }
    public static void move(char pos1,char pos3){
        System.out.println(pos1 +"->"+pos3+" ");
    }
    public static void  Hanio(int n,char pos1,char pos2,char pos3){
        if(n==1){
            move(pos1, pos3);
            return;
        }
        else{
            Hanio(n-1,pos1,pos3,pos2);
            move(pos1,pos3);
            Hanio(n-1,pos2,pos1,pos3);

        }
    }
}