JavaSE(6)-初步理解方法的定义和使用，方法重载，递归

目录

方法产生的原因

方法概念及使用

什么是方法

方法的定义

方法调用的执行过程

实参和形参的关系

没有返回值的方法

方法重载

为什么需要方法重载

方法重载概念

方法签名

递归

递归的概念

递归执行过程分析

调用栈

栈溢出

递归练习

方法产生的原因

我们来思考一个问题，为什么会存在方法呢？ 在编程中，某段功能的代码可能频繁使用到，如果在每个位置都重新实现一遍，会：

使程序变得繁琐 开发效率低下，做了大量重复性的工作 不利于维护，需要改动时，所有用到该段代码的位置都需要修改 不利于复用 因此，在编程中，我们也可以将频繁使用的代码写成方法，需要时直接调用方法使用即可，避免了一遍遍的复述，从而造成代码的冗余。

方法概念及使用

什么是方法 方法就是一个代码片段，类似于 C 语言中的 "函数"。 方法存在的意义:

模块化组织代码(当代码规模比较复杂的时候，可以分功能书写，从而层次分明，结构清晰)。做到代码被重复使用， 一份代码可以在多个位置使用。让代码更好理解，增加可读性。直接调用现有方法开发，不必重复造轮子，节省时间以及空间。 那么，方法该如何来定义呢？

方法的定义 方法语法格式

修饰符 返回值类型 方法名称([参数类型 形参1 ...]){//[]中的内容可有可无，根据需求来定
方法体代码;
[return 返回值];
}

示例: 实现一个两个整数相加的方法

public static int add(int x, int y) {
return x + y;
}

注意事项

修饰符：现阶段暂时使用public static 固定搭配返回值类型：如果方法有返回值，定义方法的返回值类型必须要与return后的实体类型一致，如果没有返回值，则必须写成void 方法名字：采用小驼峰命名 参数列表：如果方法没有参数，()中什么都不写。如果有参数，需指定参数类型，多个参数之间使用逗号隔开 方法体：方法内部执行的语句 在java当中，方法必须写在类当中在java当中，方法不能嵌套定义，方法之间是平级的，但可以在方法内调用其他方法。在java当中，没有方法声明一说，这和C语言有明显的差异。无论方法在哪个位置，都能够被调用

方法调用的执行过程

方法的调用流程

调用方法——>传递参数——>找到方法地址——>执行被调方法的方法体——>被调方法结束返回——>回到main方法继续往下执行 注意事项

定义方法的时候，不会执行方法的代码。方法只有在调用的时候才会被执行. 一个方法可以被多次调用方法调用完，它在栈区所开辟的内存就销毁了

代码示例：计算 1! + 2! + 3! + 4! + ...n!  

import java.util.Scanner;
public class Demo {
    public static void main(String[] args) {
        int sum = 0;
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入n=");
        int n=scanner.nextInt();
//将1-n的阶乘累加起来
        for (int i = 1; i <= n; i++) {
            sum += fac(i);
        }
        System.out.println("sum = " + sum);
    }
//下面的方法是计算n的阶乘
    public static int fac(int n) {
        int result = 1;
        for (int i = 1; i <= n; i++) {
            result *= i;
        }
        return result;
    }
}

实参和形参的关系 定义 Java中方法的形参是用来接收函数在调用时传递的值的。形参的名字可以随意取，对方法都没有任何影响。形参只是方法在定义时需要借助的一个变量，用来保存方法在调用时传递过来的值。 比如加法函数：

public static int add(int a, int b){
return a + b;
}
add(2, 3); // 2和3是实参，在调用时传给形参a和b

在Java中，形参是实参的一份拷贝，形参和实参本质是两个实体。但形参只有在方法被调用的时候，它才会实体化，开辟内存，在方法返回的时候，销毁在栈区的内存。 代码示例：交换两个整型变量

public class Demo{
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        swap(a, b);
        System.out.println("main: a = " + a + " b = " + b);
    }
    public static void swap(int x, int y) {
        int tmp = x;
        x = y;
        y = tmp;
        System.out.println("swap: x = " + x + " y = " + y);
    }
}
// 运行结果 
swap: x = 20 y = 10 
main: a = 10 b = 20

可以看到，在swap函数交换之后，形参x和y的值发生了改变，但是main方法中a和b还是没有改变，所以没有交换成功。我们就此展开探讨： 【原因分析】 main方法被调用，在栈区开辟了一块内存，实参a和b是main方法中的两个变量，其空间开辟在main方法的栈中。而形参x和y是swap方法中的两个变量，x和y的空间在swap方法运行时的栈中，因此：实参a和b与形参x和y是两个没有任何关联性的变量，在swap方法调用时，只是将实参a和b中的值拷贝了一份传递给了形参x和y，因此对形参x和y操作不会对实参a和b产生任何影响。 注意：对于基础类型(四类八种)来说，形参相当于实参的拷贝。即传值调用。 【解决办法】传引用类型参数 (例如数组来解决这个问题) 看下面的代码：(这里只是举个例子，不理解也无妨，只是作为一个铺垫，学习完数组之后这段代码就一目了然了)：

public class Demo{
    public static void main(String[] args) {
        int[] arr = {10, 20};
        swap(arr);
        System.out.println("arr[0] = " + arr[0] + " arr[1] = " + arr[1]);
    }
    public static void swap(int[] arr) {
        int tmp = arr[0];
        arr[0] = arr[1];
        arr[1] = tmp;
    }
}
// 运行结果
arr[0] = 20 arr[1] = 10

没有返回值的方法 方法的返回值是可以自定义的，根据需求来定，有时可以是无返回值，如果没有返回值则类型必须写成void。 例如上面的交换函数就是无返回值的。

方法重载

为什么需要方法重载

示例代码1：

public class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int ret = add(a, b);
        System.out.println("ret = " + ret);
//int类型的实参传入add方法参能够正常运行，如果是double呢？
        double a2 = 10.5;
        double b2 = 20.5;
        double ret2 = add(a2, b2);
        System.out.println("ret2 = " + ret2);
    }
    public static int add(int x, int y) {
        return x + y;
    }
}
//运行，编译出错
Test.java:13: 错误: 不兼容的类型: 从double转换到int可能会有损失
        double ret2 = add(a2, b2);
                          ^

如何让代码不报错呢？我们知道，由于参数类型不匹配，所以不能直接使用现有的 add 方法.

一种比较简单粗暴的解决方法如下(即定义多个方法，匹配不同类型)： 示例代码2：

public class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int ret = addInt(a, b);
        System.out.println("ret = " + ret);

        double a2 = 10.5;
        double b2 = 20.5;
        double ret2 = addDouble(a2, b2);
        System.out.println("ret2 = " + ret2);
    }
//定义多个匹配不同类型的方法
    public static int addInt(int x, int y) {
        return x + y;
    }
    public static double addDouble(double x, double y) {
        return x + y;
    }
}

上述代码确实可以解决问题，但不友好的地方是：需要提供许多不同的方法名，如果程序很复杂，各种稀奇百怪的方法名，会显得杂乱无章，增大我们敲代码的负担。 那能否将所有的名字都统一给成 add 呢？这就要引入一个新的概念-方法重载

方法重载概念

什么是方法重载

在我们平时的交流中，经常会出现“一词多义”的现象，比如：冰，可以说它是冰块，作为名词，也能说这个水很冰，作为形容词。一个词语如果有多重含义，那么就说该词语被重载了，具体代表什么含义需要结合具体的场景。 在Java中方法也是可以重载的： 在Java中，如果多个方法的名字相同，而参数列表不同，则称该几种方法被重载了。 示例代码

public class Test {
    public static void main(String[] args) {
        add(1, 2); // 调用add(int, int)
        add(1.5, 2.5); // 调用add(double, double)
        add(1.5, 2.5, 3.5); // 调用add(double, double, double)
    }
    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;
    }
}

注意

方法名必须相同 参数列表必须不同(参数的个数不同、参数的类型不同、类型的次序必须不同) 与返回值类型无关，两个方法如果仅仅只是因为返回值类型不同，而参数列表和方法，名都相同，这也是不能构成重载的！编译器在编译代码时，会对实参类型进行推演，根据推演的结果来确定调用哪个方法

方法签名 定义 在同一个作用域中不能定义两个相同名称的标识符。比如：在同一个方法中不能定义两个名字一样的变量，而类中却可以定义相同名字的方法，这是什么道理？我们需要对方法签名有一定的了解。 方法签名即：经过编译器编译修改过之后方法最终的名字。 方法签名的具体方式：方法全路径名+参数列表+返回值类型，构成方法完整的名字。 示例代码

public class demo2 {
    public static int add(int x, int y){
        return x + y;
    }
    public static double add(double x, double y){
        return x + y;
    }
    public static void main(String[] args) {
        add(1,2);
        add(1.5, 2.5);
    }
}

查看反汇编 上述代码经过编译之后，然后使用JDK自带的javap反汇编工具查看，具体操作：

先对工程进行编译生成.class字节码文件 在cmd控制台中进入到要查看的.class文件所在的目录 在cmd输入：javap -v 字节码文件名字即可

由此我们可以查看demo2的反汇编：

 方法签名中的一些特殊符号说明

递归

递归的概念 什么是递归 一个方法在执行过程中调用自身，就称为 "递归"。 递归相当于数学上的 "数学归纳法"， 有一个起始条件，然后有一个递推公式。 例如，我们求 N! 起始条件: N = 1 的时候，N! 为 1。这个起始条件也相当于递归的结束条件。 递归公式: 求 N! , 可以把问题转换成 N! => N * (N-1)! 递归的必要条件：

将原问题划分成其子问题，注意：子问题必须要与原问题的解法相同 有一个结束出口每次调用完自身都离这个结束出口越来越近

代码示例: 递归求 N 的阶乘

import java.util.Scanner;

public class test {
    public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
        System.out.println("请输入n=");
        int n=scanner.nextInt();
        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); // factor 调用函数自身
    }
}
// 执行结果
n=5
ret = 120

递归执行过程分析 要想理解清楚递归，必须先理解清楚方法的执行过程，尤其是在方法执行结束之后，回到调用位置继续往下执行。例如上面的程序，我们输入5，递归的内部实现大抵如下： 程序按照序号中标识的 (1) -> (8) 的顺序执行 由此我们可知道，递归，其实分为递和归的过程，1234是递，5678是归。递和归都是动词。递可以理解为传递，归可以理解为归还。

调用栈 方法调用的时候, 会有一个 "栈" 这样的内存空间描述当前的调用关系，称为调用栈. 每一次的方法调用就称为一个 "栈帧", 每个栈帧中包含了这次调用的参数是哪些, 返回到哪里继续执行等信息. 后面我们借助 IDEA 能很容易看到调用栈的内容。

栈溢出

代码示例

public class demo2 {
    public static void test(){
        test();
    }
    public static void main(String[] args) {
        test();
    }
}

 运行结果如下图所示

这就是栈溢出错误。为什么会产生栈溢出错误呢？

方法每次调用的时候，都会在栈上开辟一块内存空间，而这个递归程序没有结束的约束，所以就会无限的调用自身，从而耗尽栈内存，导致栈溢出。

递归练习

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

public static void print(int num) {
        if (num > 9) {
        print(num / 10);
        }
        System.out.println(num % 10);
}

代码示例2：递归求 1 + 2 + 3 + ... + 10

public static int sum(int num) {
        if (num == 1) {
        return 1;
        }
        return num + sum(num - 1);
}

代码示例3：求斐波那契数列的第 N 项

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

当我们求 fib(40) 的时候发现，程序执行速度极慢。 原因是进行了大量的重复运算

如何优化呢？

我们可以考虑迭代的方式避免出现冗余运算(迭代就是循环)

public static int fib(int n) {
        int last2 = 1;
        int last1 = 1;
        int cur = 0;
        for (int i = 3; i <= n; i++) {
        cur = last1 + last2;
        last2 = last1;
        last1 = cur;
        }
        return cur;
}

本章完，希望能给你带来帮助，如果再也不能见到你，也祝你早安午安，还有晚安。