Java | 方法的定义 & 重载 & 递归

方法

方法就是一段用来完成特定功能的代码片段。

  方法用于定义该类或该类的实例的行为特征和功能实现。方法是类和对象行为特征的抽象。在面向对象中，整个程序的基本单位是类，方法是从属于类和对象的。

方法的声明格式

修饰符1，修饰符2 .. 返回值类型 方法名（形式参数列表）{

  方法体;

}

• 修饰符：修饰符不是必须的要写的，java有自己默的方法饰符号。（default）
• 返回值：方法在执行完毕后返回给调用它的环境的数据。
• 返回值类型：事先约定好的返回值类型。
• 方法名：方法名是调用的时候用的，一般是用对象名调用。
• 形式参数：在方声明的时候用于接收外界传入的数据。
• 实参：调用方法时，实际传给方法的数据。
• 方法体：调用方法就是执行方法体里面的内容的。

方法的定义

    /**
     * main方法也是一个方法，它是一个程序的入口
     */
    public static void main(String[] args) {
        //调用方法的时候，得先创建一个对象
        TestOne testOne = new TestOne();
        //然后用对象调用方法
        testOne.print();
        testOne.add(1, 2);
        int a = testOne.addNum(1, 2);
        System.out.println(a);  //结果为：3
    }

    //无参的方法，无返回值的方法
    void print() {
        System.out.println("这是一个无参的方法");
    }

    //有参无返回值的方法
    void add(int a, int b) {
        System.out.println(a + b);
    }

    //有参有返回值的方法
    int addNum(int a, int b) {
        return a + b;
    }

方法的重载

方法的重载就是多个方法用同一个方法名，但是方法的参数列表不相同，参数的个数，参数的顺序不相同，参数的类型不相同。只是返回不相同可不是重载。

 &esmp;方法的重载本质是两个方法本来就不是一个方法，只是名字相同罢了。

    /**
     * 原始方法 下面所有的方法名都一样。
     * 但是参数上的不同，可以非常多的重载方法。
     */
    int add(int a, int b) {
        return a + b;
    }

    //参数的个数不相同
    int add(int a, int b,int c) {
        return a + b + c;
    }

    //形参不一样
    double add(double a,int b) {
        return a + b;
    }

    //形参不一样
    double add(int a,double b) {
        return a + b;
    }

    /*
    //错误的，只有返回不相同不可以
    long add(int a, int b) {
        return a + b;
    }
    //错误的，参数名不相同也不可以
    int add(int b, int a) {
        return a + b;
    }
    */

方法的递归

递归的本质就是一个方法自己调用自己。

  但是递归是一种常见的解决问题的方法，即把问题简单化。利用递归可以用一些简单的程序来解决一些复杂的问题。

要使用递归必须要定义以下两点

1、定义递归头：就是什么时候不调用自身的方法。如果没有递归头，这个递归就是一个死循环。

2、递归体：就是什么时候需要调用自己。

只要掌握这两个的写法，就可以写好一个递归了。

下面有一个小例子来说明一下递归：（求n的乘阶）

public static void main(String[] args) {
    long time1 = System.currentTimeMillis();    //求出程序执行前的时间
    long a = sumNum(10);                //递归的方法
    long time2 = System.currentTimeMillis();    //求出程序执行后的时间
    System.out.println("递归的结果是：" + a); //递归的结果是：3628800
    System.out.println("花费的时间是：" + (time1 - time2));//花费的时间是：1

    System.out.println("*************************");

    long time3 = System.currentTimeMillis();    //求出程序执行前的时间
    long b = sumNum2(10);                //循环的方法
    long time4 = System.currentTimeMillis();    //求出程序执行后的时间
    System.out.println("循环的结果是：" + a); //递归的结果是：3628800
    System.out.println("花费的时间是：" + (time3 - time4));//花费的时间是：0
}

//用递归求n的乘阶
static long sumNum(int n) {
    if (n == 1) {   //递归头
        return 1;
    } else {        //递归体
        return n * sumNum(n - 1);
    }
}

//用循环求n的乘阶
static long sumNum2(int n) {
    int result = 1; //接收计算结果
    while(n>1) {
        result *= n*(n-1);  //实现计算结果的累乘操作
        n -= 2; //每次减去2，实现数字的迭代操作
    }
    return result;
}

  上面这张图片说明了，递归是一个方法套一个方，然后从递归头结束，再进行返回，所以说执行的速度比循环慢。

  这两个例子表明，递归还是不如循环好使，因为大部分递归可以实现的东西，循环都可以实现，并且比递归还要好理解，并且不占内存，不会报无缘无故的错，并且循环执行的时间比递归的时间执行的时间少。

  但是并不是全都不使用递归了，该用的地方还是会用递归的，但是常用的方法，我们还是用循环解决吧！

---

细节决定成败!

个人愚见，如有不对，恳请扶正!