Java中的函数（重载与递归）

最新推荐文章于 2024-07-08 00:01:13 发布

Smiling Mr. Rui

最新推荐文章于 2024-07-08 00:01:13 发布

阅读量793

点赞数 26

分类专栏：网络安全文章标签： java 开发语言

本文链接：https://blog.csdn.net/AXDRXS/article/details/138380549

版权

网络安全专栏收录该内容

14 篇文章 0 订阅

订阅专栏

前言：

函数也叫方法，它是一个解决特定问题的代码块，这个代码块可以被反复使用。为了让我们的程序更利于维护，也让我们程序更好复用。所以我们需要使用函数。

一、如何定义函数

在 Java 中函数定义需要有一个固定的格式：

访问修饰符 方法返回值类型 方法名称([参数列表]) [抛出异常] {
    方法体;
    [return 返回值;]
}

1.1 访问修饰符

public 这是公共，所有都可以访问
private 这是私有的，只能自己访问
protected 这是受保护的，只能它自己或它的子类访问

1.2 方法返回值类型

基本数据类型
引用数据类型

1.3 方法名称

方法名称定义需要符合标识符的命名规则。

1.4 参数列表

它在方法中是可以没的，如果有多个参数，则参数与参数之间使用英文逗号分隔
参数的声明格式为：参数类型参数名称

1.5 抛出异常

此部分是可以没有，如果有则需要使用 throws 来向外抛出
如果有多个异常，则使用逗号分隔

1.6 返回值

如果方法执行后需要有返回值，则必须使用 return 关键字来返回
方法的返回值类型要与 return 后面的值的类型一致
如果方法返回返回值类型（如 void），那么方法中也可以没有 return 语句，也可以有。如果有 return 后不能有值。

例如，我们在 MethodDemo01中定义一个 show 方法和一个add方法。

public class MethodDemo01 {
    public static void main(String[] args) {
        show();
    }

    public static int add(int a, int b) {
        int result = a + b;
        return result;
    }
    public static void show() {
        System.out.println("大家下午好！");
        return;
    }
}

方法使用案例：计算最大值。

public class MethodDemo02 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        //System.out.println(Math.max(a, b));
        int r = max(a, b);
        System.out.println(r);
    }

    public static int max(int a, int b) {
        return Math.max(a, b);
        //return a > b ? a : b;

        //if (a > b) {
        //    return a;
        //} else {
        //    return b;
        //}
    }
}

二、函数执行原理

每当调用一个方法时，系统会创建一个活动记录（也称为活动框架），用于保存方法中的参数和变量。活动记录置于一个内存去榆中，称为调用堆栈（call stack）。调用堆栈也称为执行堆栈、运行时堆栈，或者一个机器堆栈，常简称为“堆栈”。当一个方法调用另一个方法时，调用者的活动记录保持不动，一个新的活动记录被创建用于被调用的新方法。一个方法结束返回到调用者时，其相应的活动记录也被释放。

2.1 函数重载

如果在一个类中有多个方法的名称相同，它的参数列表不同。那么这些方法就构成了重载方法。

2.1.1 重载方法的特点

如何判断方法是否是重载方法，可以根据它的特点来判断。重载方法具有以下特点：

方法名称必须相同
参数列表必须不同（包括参数类型、参数顺序、参数个数）
与方法的返回值无关
必须是在同一个类中

2.1.2 重载方法的使用

需求：实现两个数相加操作的功能。

public class MethodDemo03 {
    public static void main(String[] args) {
        System.out.println(add(2, 3.0f));
    }

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

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

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

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

2.2 函数的递归

所谓递归就是函数的内部调用其本身。在使用递归时，必须要有一个出口来退出递归的操作，否则需要产生栈溢出的错误。

假设我们需要计算 6! 的值，此时可以使用到递归。

1）非递归的实现

public class MethodDemo04 {
    public static void main(String[] args) {
        int n = 6;
        System.out.println(recursion(n));
    }

    public static int recursion(int x) {
        int sum = 1;
        for (int i = x; i >= 1; i--) {
            sum *= i;
        }
        return sum;
    }
}

2）使用递归的实现

public class MethodDemo05 {
    public static void main(String[] args) {
         System.out.println(recursion(6));
    }
    public static int recursion(int x) {
        if (x == 1) return 1;
        else return x * recursion(x -1);
    }
}

示例学习：递归实现斐波那契数列

斐波那契数列的格式为：1 1 2 3 5 8 13 21 ....，从第三个数开始就是前两个数的和。

我们来计算 20 个数的斐波那契数列的和是多少：

public class MethodDemo6 {
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 1; i <= 20; i++) {
            sum += fibola(i);
        }

        System.out.println("sum = " + sum);
    }
    public static int fibola(int num) {
        if (num == 1 || num == 2) {
            return 1;
        } else {
            return fibola(num-1) + fibola(num-2);
        }
    }
}

示例学习：汉诺塔问题

public class MethodDemo07 {
    public static void main(String[] args) {
        hanno(3, "A", "B", "C");
    }

    public static void hanno(int n, String  a, String b, String c) {
        if (n == 1) {
            System.out.println("a -> c");
        } else {
            hanno(n-1, a, c, b);
            System.out.println("a -> c");
            hanno(n-1, b, a, c);
        }
    }
}