Java中关于方法的调用和递归

1.方法的调用

2.方法的重载

3.递归

在Java中，相较于C/C++，Java没有函数这一概念，而是用方法，所以可以通俗的讲方法其实也就是函数（个人的理解）,所以有C/C++的基础之上，学习方法也就是举一反三的事，也非常的简单，下面我会讲解如何创建方法以及如何调用方法

1.方法的创建

我们已俩个数相加为例子进行展开，我们现在有俩个数分别为a = 10，b = 20，我们要把这俩个数相加也非常的容易，如：

public class Test {

    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = a + b;
        System.out.println(c);
    }
}

这时候我们会想，直接相加就可以了呀，为什么还要创建那么多个方法呢？因为我们当前只是对a和b进行相加而已，如果在以后的开发过程中，如果要对100个不同数俩俩相加，那么我们岂不是要写很多很多个相加的代码，这会让我们的开发效率非常的低，这时候我们可以创建一个俩个数相加的方法，当我们需要对俩个数进行相加的时候，我们可以直接调用方法，一行代码即可搞定，就不需要写冗余的代码！！~~

下面是我们对上面俩个数相加创建的一个方法

public class Test {

//这里传的是形参
    public static int add(int x, int y) {
        return x + y;    
}

    public static void main(String[] args) {

        int c = add(10,20);//这里传的是实参
        System.out.println(c);


        c = add(100, 200);
        System.out.println(c);

        c = add(13331, 200421);
        System.out.println(c);
    }
}

我们通过创建方法，就可以很高效并且不会重复大量的代码进行开发，也就是说方法存在的意义，是为了让我们减少造轮子，高效率的开发，节省时间

那我们又会想到，上面是关于俩个整型int进行相加，那如果我们需要俩个小数进行相加，一个整数和一个小数进行相加....等等，那我们岂不是要写好多个不同方法并且为他们提供不同的名字，这样也很累呀，所以在Java中,为我们提供了关于方法的重载，在C/C++中也有

2.方法的重载

如果我们不使用重载，我们再写开发过程中也很慢，因为我们不仅仅需要给方法起不同的名字，还需要在调用的时候精准调用我们需要的方法，所以如果我们不适用重载的话，即使有方法，也会阻碍我们进步的步伐~~~

下面是不用重载对方法进行创建，我们分别对俩个整型进行相加，一个整型和一个小数进行相加，俩个小数进行相加，这只是我们部分情况。

public class Test {

//俩个整型相加
    public static int addInt(int x, int y) {
        return x + y;    
    }

//俩个浮点数相加
    public static double addDouble(double x, double y) {
        return x + y;
    }

//一个整型和浮点数相加
    public static double addIntDouble(int x, double y) {
        return x + y;
    }

//一个浮点数和整型相加
    public static double addDoubleInt(double x, int y) {
        return x + y;
    }

    public static void main(String[] args) {

        int c = addInt(10,20);
        System.out.println(c);


        double a = addDouble(100.63, 200.231);
        System.out.println(a);

        a = addIntDouble(131, 20042.1);
        System.out.println(a);


        a = addDoubleInt(131.31, 2004);
        System.out.println(a);
    }
}

如果我们需要不同数据类型相加，那我们就要创建非常多的方法，这样子会让我们的代码显得非常的冗余，所以在Java中为我们提供了方法的重载，它可以自动识别参数的个数，参数的数据类型，参数的顺序，自动为我们匹配合适的方法，在调用的过程中也可以为我们节省时间

方法重载的要求：1.方法名称相同 2.参数的数据类型or参数个数or参数顺序不同 3.返回值不影响

下面使用重载，优化上面的代码,在编译的时候，编译器会按照参数自动匹配方法，为我们节省不少的时间和工作，提高开发的效率

public class Test {

//俩个整型相加
    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(int x, double y) {
        return x + y;
    }

//一个浮点数和整型相加
    public static double add(double x, int y) {
        return x + y;
    }

//三个整型相加
    public static int add(int x, int y, int z) {
        return x + y + z;
    }

    public static void main(String[] args) {

        int c = add(10,20);
        System.out.println(c);


        double a = add(100.63, 200.231);
        System.out.println(a);

        a = add(131, 20042.1);
        System.out.println(a);


        a = add(131.31, 2004);
        System.out.println(a);

        c = add(10, 20, 30);
        System.out.println(c);
    }
}

3.递归

递归的思想是比较困难的，包括我也写过不少的递归，但是递归的思想还是没有完全建立和熟悉

但是也不要灰心，我个人认为递归要抓住俩个核心：1.递归的出口（结束条件）2.递归的方法

下面我们通过几道递归的题目来感受一下递归

1.使用递归求N的阶乘

1！= 1*1   

2！= 1*2 = 2*（2-1）！

3！= 1*2*3 = 3*（3-1）！

4！= 1*2*3*4= 4*（4-1）！

所以我们可以总结出N！= N*（N-1）

public class Test {

    public static int fun(int n) {
       //递归的出口
        if(n == 1) {
            return 1;
        }


        //递归的思想
        return n*fun(n-1);
    }


    public static void main(String[] args) {
            int N = 5;
            int ret = fun(N);

            System.out.println(ret);
    } 
}

2.使用递归按顺序打印⼀个数字的每⼀位(例如1234打印出1234)

这道题目是想让我们输入一个整数，如1234，然后打印出来每一位1 2 3 4

那么我们可以使用%和/配合使用得到每一位

public class Test{
    public static void print(int n) {
//当整数只剩下个位数时候，直接打印 --- 也是递归的出口
        if(n < 10) {
            System.out.print(n + "->");
        }else {
            print(n/10);
            System.out.print(n%10 + "->");
        }
    }

    public static void main(String[] args) {
        int N = 1234;
        print(N);
    }

}

3.输⼊⼀个⾮负整数，返回组成它的数字之和.例如，输⼊1729,则应该返回1+7+2+9，它的和是19

这道题目和上一道题目一样同理，可以使用%和/配合使用，递归的出口是一样的，可能在思想上会有略不同

public class Test{
    public static int sum(int n) {
//当n整数为个位数的时候就返回n即可 --- 也是递归的出口
        if(n < 10) {
            return n;
        }else {
            return (n%10) + sum(n/10);
        }       
    }


    public static void main(String[] args) {
        int N = 1729;
        int ret = sum(N);
        System.out.println(ret);
    }

{