第五章方法-CSDN博客

本文链接：https://blog.csdn.net/weixin_45698983/article/details/130195361

文章目录

1. 方法概念及使用
2. 方法重载
- 2.1 方法重载概念
- 2.2 方法签名
3. 递归

1. 方法概念及使用

1.1 什么是方法(method)

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

是能够模块化的组织代码(当代码规模比较复杂的时候).
做到代码被重复使用, 一份代码可以在多个位置使用.
让代码更好理解更简单.
直接调用现有方法开发, 不必重复造轮子.

1.2 方法定义

方法语法格式

// 方法定义
修饰符 返回值类型 方法名称([参数类型 形参 ...]){
    方法体代码;
    [return 返回值];
}

**示例：**实现一个函数，检测一个年份是否为闰年

// 方法定义
public static boolean isLeapYear(int year) {
    if ((0 == year % 4 && 0 != year % 100) || 0 == year % 400) {
        return true;
    } else {
        return false;
    }
}

【注意事项】

修饰符：现阶段直接使用public static 固定搭配
返回值类型：如果方法有返回值，返回值类型必须要与返回的实体类型一致，如果没有返回值，必须写成void
方法名字：采用小驼峰命名
参数列表：如果方法没有参数，()中什么都不写，如果有参数，需指定参数类型，多个参数之间使用逗号隔开
方法体：方法内部要执行的语句
在java当中，方法必须写在类当中
在java当中，方法不能嵌套定义
在java当中，没有方法声明一说

1.3 方法调用的执行过程

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

定义方法的时候, 不会执行方法的代码. 只有调用的时候才会执行
一个方法可以被多次调用.

1.4 实参和形参的关系(重要)

方法的形参相当于数学函数中的自变量，比如：1 + 2 + 3 + … + n 的公式为
在这里插入图片描述

Java中方法的形参就相当于sum函数中的自变量n，用来接收sum函数在调用时传递的值的。
形参的名字可以随意取，对方法都没有任何影响，形参只是方法在定义时需要借助的一个变量，用来保存方法在调用时传递过来的值。
例如：

public static int getSum(int N){ // N是形参
	return (1+N)*N / 2;
}

getSum(10); // 10是实参,在方法调用时，形参N用来保存10
getSum(100); // 100是实参，在方法调用时，形参N用来保存100

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

add(2, 3); // 2和3是实参，在调用时传给形参a和b

注意：
在Java中，实参的值永远都是拷贝到形参中，形参和实参本质是两个实体
代码实例：

public static void swap(int a, int b) {
    int tmp = a;
    a = b;
    b = tmp;
    System.out.println("交换后：a = " + a + ", b = " + b);
}

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

实参 a 和 b 是 main 方法中的两个变量，其空间在main方法的栈(一块特殊的内存空间)中，而形参x和y是swap方法中的两个变量，x 和 y 的空间在swap方法运行时的栈中，因此：实参a和b 与形参x和y是两个没有任何关联性的变量，在swap方法调用时，只是将实参a和b中的值拷贝了一份传递给了形参x和y，因此对形参x和y操作不会对实参a和b产生任何影响。

注意：对于基础类型来说，形参相当于实参的拷贝，即 传值调用

1.5 没有返回值的方法

方法的返回值是可选的. 有些时候可以没有的，没有时返回值类型必须写成void

2. 方法重载

2.1 方法重载概念

在自然语言中，一个词语如果有多重含义，那么就说该词语被重载了，具体代表什么含义需要结合具体的场景。在Java中方法也是可以重载的。
在Java中，如果多个方法的名字相同，参数列表不同，则称该几种方法被重载了。
注意：

方法名必须相同
参数列表必须不同 (参数的个数不同、参数的类型不同、类型的次序必须不同)
与返回值类型是否相同无关
编译器在编译代码时，会对实参类型进行推演，根据推演的结果来确定调用哪个方法

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

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

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

2.2 方法签名

在同一个作用域中不能定义两个相同名称的标识符。比如：方法中不能定义两个名字一样的变量，那为什么类中就可以定义方法名相同的方法呢？
方法签名即：经过编译器编译修改过之后方法最终的名字。具体方式：方法全路径名+参数列表+返回值类型，构成方法完整的名字。

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

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

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

public static void main(String[] args) {
    add(1, 2);
    add(1.1, 2.2, 3.3);
}

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

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

Constant pool:
   #1 = Methodref          #11.#34        // java/lang/Object."<init>":()V
   #2 = Methodref          #10.#35        // Test2.add:(II)I
   #3 = Double             1.1d
   #5 = Double             2.2d
   #7 = Double             3.3d
   #9 = Methodref          #10.#36        // Test2.add:(DDD)D
  #10 = Class              #37            // Test2
  #11 = Class              #38            // java/lang/Object
  #12 = Utf8               <init>
  #13 = Utf8               ()V
  #14 = Utf8               Code
  #15 = Utf8               LineNumberTable
  #16 = Utf8               LocalVariableTable
  #17 = Utf8               this
  #18 = Utf8               LTest2;
  #19 = Utf8               add
  #20 = Utf8               (II)I
  #21 = Utf8               a
  #22 = Utf8               I
  #23 = Utf8               b
  #24 = Utf8               (III)I
  #25 = Utf8               c
  #26 = Utf8               (DDD)D
  #27 = Utf8               D
  #28 = Utf8               main
  #29 = Utf8               ([Ljava/lang/String;)V
  #30 = Utf8               args
  #31 = Utf8               [Ljava/lang/String;
  #32 = Utf8               SourceFile
  #33 = Utf8               Test2.java
  #34 = NameAndType        #12:#13        // "<init>":()V
  #35 = NameAndType        #19:#20        // add:(II)I
  #36 = NameAndType        #19:#26        // add:(DDD)D
  #37 = Utf8               Test2
  #38 = Utf8               java/lang/Object
{
  public Test2();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: return
      LineNumberTable:
        line 9: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       5     0  this   LTest2;

  public static int add(int, int);
    descriptor: (II)I
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=2, args_size=2
         0: iload_0
         1: iload_1
         2: iadd
         3: ireturn
      LineNumberTable:
        line 12: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       4     0     a   I
            0       4     1     b   I

  public static int add(int, int, int);
    descriptor: (III)I
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=3, args_size=3
         0: iload_0
         1: iload_1
         2: iadd
         3: iload_2
         4: iadd
         5: ireturn
      LineNumberTable:
        line 16: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       6     0     a   I
            0       6     1     b   I
            0       6     2     c   I

  public static double add(double, double, double);
    descriptor: (DDD)D
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=4, locals=6, args_size=3
         0: dload_0
         1: dload_2
         2: dadd
         3: dload         4
         5: dadd
         6: dreturn
      LineNumberTable:
        line 20: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       7     0     a   D
            0       7     2     b   D
            0       7     4     c   D

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=6, locals=1, args_size=1
         0: iconst_1
         1: iconst_2
         2: invokestatic  #2                  // Method add:(II)I
         5: pop
         6: ldc2_w        #3                  // double 1.1d
         9: ldc2_w        #5                  // double 2.2d
        12: ldc2_w        #7                  // double 3.3d
        15: invokestatic  #9                  // Method add:(DDD)D
        18: pop2
        19: return
      LineNumberTable:
        line 24: 0
        line 25: 6
        line 26: 19
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      20     0  args   [Ljava/lang/String;
}
SourceFile: "Test2.java"

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

特殊字符	数据类型
V	void
Z	boolean
B	byte
C	char
S	short
I	int
J	long
F	float
D	double
[	数组(以[开头，配合其他的特殊字符，表述对应数据类型的数组，几个[表述几维数组)
L	引用类型，以L开头，以;结尾，中间是引用类型的全类名

3. 递归

3.1 递归的概念

一个方法在执行过程中调用自身, 就称为 “递归”.
递归相当于数学上的 “数学归纳法”, 有一个起始条件, 然后有一个递推公式.
递归的必要条件：

将原问题划分成其子问题，注意：子问题必须要与原问题的解法相同
递归出口

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

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

3.2 递归执行过程分析

递归的程序的执行过程不太容易理解，要想理解清楚递归，必须先理解清楚 “方法的执行过程”，尤其是 “方法执行结束之后，回到调用位置继续往下执行”.
**代码示例： **

public static int fac(int n) {
    System.out.println("函数开始，n = " + n);
    if (n == 1) {
        System.out.println("函数结束，n = 1，ret = 1");
        return 1;
    }
    int ret = n * fac(n - 1);
    System.out.println("函数结束，n = " + n + "，ret = " + ret);
    return ret;
}

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

函数开始，n = 5
函数开始，n = 4
函数开始，n = 3
函数开始，n = 2
函数开始，n = 1
函数结束，n = 1，ret = 1
函数结束，n = 2，ret = 2
函数结束，n = 3，ret = 6
函数结束，n = 4，ret = 24
函数结束，n = 5，ret = 120
120

执行过程图

关于 “调用栈”
方法调用的时候, 会有一个 “栈” 这样的内存空间描述当前的调用关系，称为调用栈.
每一次的方法调用就称为一个 “栈帧”，每个栈帧中包含了这次调用的参数是哪些，返回到哪里继续执行等信息

3.3 递归练习

**代码示例1： **

public static void print(int n) {
    if (n < 10) {
        System.out.println(n);
        return;
    }
    print(n / 10);
    System.out.println(n % 10);
}

public static void main(String[] args) {
    print(123);
}

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

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

例如，输入 1729, 则应该返回 1+7+2+9，它的和是19
public static int sumNum(int n) {
    if (n < 10) {
        return n;
    }
    int tmp = sumNum(n / 10) + n % 10;
    return tmp;
}

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

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 last1 = 1;
    int last2 = 1;
    int cur = 0;
    for (int i = 3; i <= n; i++) {
        cur = last1 + last2;
        last2 = last1;
        last1 = cur;
    }
    return cur;
}