Java中方法的使用、重载与递归的详细介绍

目录

• 一.方法的基本使用
• 1.什么是方法
• 2.方法基本语法
• 二.方法的重载
• 1.重载的作用
• 2.重载的使用规则
• 三.方法的递归
• 1.递归的概念
• 2.递归执行过程分析
• 3.递归练习
• 1.按顺序打印一个数字的每一位
• 2.递归求 1 + 2 + 3 + ... + 10
• 3.返回组成它的数字之和
• 4.求斐波那契数列的第 N 项

一.方法的基本使用

1.什么是方法

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

2.方法基本语法

基本语法

 // 方法定义
    public static 方法返回值 方法名称（参数类型 形参){
        方法体代码;
        return 返回值;
    }

    public static void main(String[] args) {
        // 方法调用
        返回值变量 = 方法名称 (实参);
    }

看到这里可能有点抽象，接下来写一个具体的方法：两个整数相加

public class TestDemo {
    // 方法定义
    public static int Add(int x,int y){
        int sum = x+ y;
        return sum;
    }

    public static void main(String[] args) {
        //方法的调用
        Add(10,20);
        System.out.println(Add(10,20));
    }
}

注意事项

1.方法定义时, 参数可以没有。每个参数要指定类型

2.方法定义时, 返回值也可以没有, 如果没有返回值, 则返回值类型应写成 vo

3.方法定义时的参数称为形式参数（形参），方法调用时的参数称为实际参数（实参）

4.方法的定义必须在类之中, 代码书写在调用位置的上方或者下方都可以

5.所有程序的入口：main函数

形参与实参的关系

首先我们写一个交换两个数的方法，并运行一下

public class Test1 {
    public static void swap(int a,int b){
        int temp = a;
        a = b;
        b = temp;
    }

    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println("交换实参前："+a+" "+b);
        swap(a,b);
        System.out.println("交换实参后："+a+" "+b);
    }
}

为什么没有发生任何改变呢？

因为我们交换的是形参，而不是交换的实参。如果要交换实参，我们应该拿到a和b的地址，但是！a和b在main函数中，函数里的变量属于局部变量，存放在栈上。但是在Java中，拿不到栈上的地址，所以a和b的实际值并没有发生改变。如果要交换a和b的值，只能把a和b的值放在堆上（放在堆上的都是对象！！）

二.方法的重载

1.重载的作用

前面我们提到了方法需要参数类型，但是如果我们需要用一个函数同时兼容多种参数的情况应该怎么办呢？ 这里就可以使用到方法重载

在我们写了一个add方法后，如果我们想用这个方法计算double类型的时候，会出现类型不兼容的问题，那么我们应该怎么解决呢？或许可以像下面这样

public class Test2 {
    public static int addInt(int a, int b){
        int sum = a+b;
        return sum;
    }

    public static double addDouble(double a,double b){
        double sum = a+b;
        return sum;
    }

    public static void main(String[] args) {
        double a = 10.5;
        double b = 20.5;
        addDouble(a,b);
        System.out.println(addDouble(a,b));
    }
}

这种写法不存在任何问题，例如在go语言中就这样使用，但是Java认为addInt这种名字不太好，不如直接叫add，这就有了如下写法

public class Test2 {
    public static int add(int a, int b){
        int sum = a+b;
        return sum;
    }

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

    public static void main(String[] args) {
        double a = 10.5;
        double b = 20.5;
        add(a,b);
        System.out.println(add(a,b));
    }
}

运行起来也没有任何问题，这就是重载的作用！能解决参数类型不匹配等问题。比如add方法，你还能添加更多版本的使用，比如多个数相加...

同一个方法名字, 提供不同版本的实现，称为方法的重载

2.重载的使用规则

针对同一个类:

1.方法名相同

2.方法的参数不同(参数个数或者参数类型)

3.方法的返回值类型不影响重载

4.当两个方法的名字相同, 参数也相同, 但是返回值不同的时候, 不构成重载。比如int add（int a，int b）和double add（int a，int b）

三.方法的递归

1.递归的概念

递归就是方法调用自己的过程。实现递归，需要去推导出递归公式。

递归的前提：有一个趋近于终止的条件、自己调用自己

递归的关键：就是要找到递归公式！理解"递"和"归"的过程

2.递归执行过程分析

public class Test3 {
    public static int fac(int n){
        if(n==1){
            return 1;
        }
        int temp = n*fac(n-1);
        return temp;
    }

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

具体过程分析：

3.递归练习

相信看到这里，你对递归也有了一定的认识，可以适当练习一些题增加熟练度。附上笔者的答案，如有错误，请斧正！

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

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

public class Demo1 {
    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 = 1234;
        print(n);
    }
}

2.递归求 1 + 2 + 3 + ... + 10

递归求 1 + 2 + 3 + ... + 10

public class Demo2 {
    public static int func(int n){
        if(n!=0){
            n += func(n-1);
        }
        return n;
    }
    public static void main(String[] args) {
        System.out.println(func(10));
    }
}

3.返回组成它的数字之和

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

public class Demo3 {
    public static int func(int n){
        if(n<10){
            return n;
        }
        return n%10+func(n/10);
    }

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

4.求斐波那契数列的第 N 项

解法一：使用递归，时间复杂度为O(2^n)，空间复杂度为O(n)

public class Demo4 {
    public static int fib(int n){
        if(n==1 || n == 2){
            return 1;
        }else{
            return fib(n-1)+fib(n-2);
        }
    }

    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(123456));
    }
}

但是这种解法效率并不高，再计算较大数字时就会明显出现停顿，因为它会进行很多重复的运算，于是我们可以用循环写这个代码，也叫迭代解法

解法二：使用迭代，时间复杂度为O(n)，空间复杂度为O(1)

public class Demo4 {

    public static int fib2(int n){
        if(n==1 || n==2){
            return 1;
        }
        int f1 = 1;
        int f2 = 1;
        int f3 = 0;
        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(fib2(1));
        System.out.println(fib2(2));
        System.out.println(fib2(3));
        System.out.println(fib2(4));
        System.out.println(fib2(40));
    }
}

到此这篇关于Java-方法的使用、重载与递归的文章就介绍到这了,更多相关Java重载递归内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！