Java~方法的使用【方法的定义及使用、方法传参、方法重载、递归】

最新推荐文章于 2022-11-04 18:44:59 发布

Li_yizYa

最新推荐文章于 2022-11-04 18:44:59 发布

阅读量449

点赞数 7

分类专栏： Java 文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/qq_58284486/article/details/123016727

版权

Java 专栏收录该内容

71 篇文章 4 订阅

订阅专栏

求1 + 2 + 3 + ... + 10

计算数字的每个位数之和

求斐波那契数的第N项

方法的概念及使用

方法就是一个代码片段，类似于C语言中的“函数”。

方法存在的意义：

1.能够模块化的组织代码；

2.实现代码可以被重复使用，一个代码可以在多个位置使用；

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

4.当遇到同一问题处理方式时，直接调用现有方法，不需要重复编写代码。

方法的定义

方法的语法格式

修饰符 返回值类型 方法名称(参数类型 ){
    方法体代码;
    return 返回值;
}

方法的定义举例：

①实现一个函数，检测一个年份是否为闰年

    public static boolean isLeapYear(int year){
        if(year%4 == 0 && year%10 != 0 || year%400 == 0){
            return true;
        }else{
            return false;
        }
    }

②定义一个两数相加的方法

public static int add(int a, int b){
        return a + b;
    }

注意事项：

1.返回值类型必须与返回的实体类型一致，如果没有返回值，则写成void；

2.方法的名称：采用小驼峰命名；

3.在Java中，方法必须写在类当中；

4.在Java中，方法不能嵌套定义；

5.在Java中，不需要像C语言那样对方法进行声明.

方法的使用

方法调用的过程

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

注意事项：

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

2.一个方法可以被多次调用.

代码示例：计算：1！+ 2！+ 3！+ 4！+ 5！

public class TestDemo {
    public static int num(int x){
        int ret = 1;
        for (int i = x; i > 0; i--) {
            ret *= i;
        }
        return ret;
    }
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 1; i <= 5; i++) {
            sum += num(i);
        }
        System.out.println(sum);
    }
}

实参和形参的关系

方法的形参相当于数学函数中的自变量，形参即方法所接收的参数，实参即为调用方法时所传递的参数。形参的名字可以随意取，对方法无任何影响，形参只是方法在定义时需要借助的一个变量，用来保存方法在调用时传递过来的值。

注意：在Java中，实参的值永远只是copy到形参中，实参和形参本质上是两个实体。对于基础类型来说，形参相当于实参的copy，即传值调用。

方法重载

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

例如：

public class TestDemo{
    public static void main(String[] args) {
        int ret1 = add(1, 2);
        double ret2 = add(1.5, 2.5);
        double ret3 = add(1.5, 2.5, 3.5);
        System.out.println(ret1 + ret2 + ret3);
    }
    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.递归出口。

代码示例：递归求n的阶乘

public class TestDemo{
    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;
        }
        return n * factor(n - 1);
    }
}

在上述代码中，求n的阶乘就在求阶乘的方法中使用了递归的方式实现。

对于上述代码的递归执行进行过程分析：

public class TestDemo{
    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;
    }
}

递归过程分析：

① ret = 5 * factor(5 - 1);
② factor(4) = 4 * factor(4 - 1);
③ factor(3) = 3 * factor(3 - 1);
④ factor(2) = 2 * factor(2 - 1);
⑤ factor(1) = 1;
所以ret = 5 * 4 * 3 * 2 * 1 = 120

递归练习

按顺序打印一个数字的每一位

按顺序打印一个数字的每一位，例如输入1234，打印 1 2 3 4.

public class TestDemo1 {
    public static void print(int n){
        if(n > 9){
            print(n / 10);
        }
        System.out.print(n % 10 + " ");
    }
    public static void main(String[] args) {
        int n = 13685884;
        print(n);
    }
}

求1 + 2 + 3 + ... + 10

利用递归的方法求1 + 2 + 3 + ... + 10

public class TestDemo2 {
    public static int sum(int n){
        if(n == 1){
            return 1;
        }
        return n + sum(n - 1);
    }
    public static void main(String[] args) {
        int n = 10;
        int ret = sum(n);
        System.out.println("1 + 2 + 3 + ... + 10 = " + ret);
    }
}

计算数字的每个位数之和

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

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

求斐波那契数的第N项

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

在求斐波那契数时，递归的方法相较于迭代来说效率较为低下，因此最好利用迭代的方式来实现该问题.

public class TestDemo4 {
    public static int fib1(int n){
        int f1 = 1;
        int f2 = 1;
        int f3 = 0;
        if(n == 1 || n == 2){
            return 1;
        }else{
            for (int i = 2; i < n; i++) {
                f3 = f1 + f2;
                f1 = f2;
                f2 = f3;
            }
        }
        return f3;

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

Li_yizYa

关注

7
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
2
评论
Java~方法的使用【方法的定义及使用、方法传参、方法重载、递归】

目录方法的概念及使用方法的定义方法的使用方法重载递归递归练习按顺序打印一个数字的每一位求1 + 2 + 3 + ... + 10计算数字的每个位数之和求斐波那契数的第N项方法的概念及使用方法就是一个代码片段，类似于C语言中的“函数”。方法存在的意义：1.能够模块化的组织代码；2.实现代码可以被重复使用，一个代码可以在多个位置使用；3.让代码更好理解、更简单；4.当遇到同一问题处理方式时，直接调用现有方法，不需要重复编写代码。方.
复制链接

扫一扫