第五章 方法

文章目录

  • 1. 方法概念及使用
    • 1.1 什么是方法(method)
    • 1.2 方法定义
    • 1.3 方法调用的执行过程
    • 1.4 实参和形参的关系(重要)
    • 1.5 没有返回值的方法
  • 2. 方法重载
    • 2.1 方法重载概念
    • 2.2 方法签名
  • 3. 递归
    • 3.1 递归的概念
    • 3.2 递归执行过程分析
    • 3.3 递归练习

1. 方法概念及使用

1.1 什么是方法(method)

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

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

1.2 方法定义

方法语法格式

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

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

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

【注意事项】

  1. 修饰符:现阶段直接使用public static 固定搭配
  2. 返回值类型:如果方法有返回值,返回值类型必须要与返回的实体类型一致,如果没有返回值,必须写成void
  3. 方法名字:采用小驼峰命名
  4. 参数列表:如果方法没有参数,()中什么都不写,如果有参数,需指定参数类型,多个参数之间使用逗号隔开
  5. 方法体:方法内部要执行的语句
  6. 在java当中,方法必须写在类当中
  7. 在java当中,方法不能嵌套定义
  8. 在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中,如果多个方法的名字相同,参数列表不同,则称该几种方法被重载了
注意:

  1. 方法名必须相同
  2. 参数列表必须不同 (参数的个数不同、参数的类型不同、类型的次序必须不同)
  3. 与返回值类型是否相同无关
  4. 编译器在编译代码时,会对实参类型进行推演,根据推演的结果来确定调用哪个方法
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;
}

第五章 方法_第1张图片

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反汇编工具查看,具体操作:

  1. 先对工程进行编译生成.class字节码文件
  2. 在控制台中进入到要查看的.class所在的目录
  3. 输入:javap -v 字节码文件名字即可
Constant pool:
   #1 = Methodref          #11.#34        // java/lang/Object."":()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        // "":()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."":()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 递归的概念

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

  1. 将原问题划分成其子问题,注意:子问题必须要与原问题的解法相同
  2. 递归出口
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

执行过程图
第五章 方法_第2张图片

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

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;
}

你可能感兴趣的:(JavaSE,java,jvm,开发语言)