方法的概念及使用

---

---

什么是方法

方法是类的行为或功能的实现，类似于其他语言中的 “函数”。

方法的定义

方法的语法格式（如下）：

修饰符 返回值类型 方法名(参数列表) {
    // 方法体（执行代码）
    return 返回值;  // 如果返回值类型非void，则必须有return语句
}

修饰符：
可选，如 public、private、static 等，控制方法的访问权限和特性
返回值类型：
方法执行后返回的数据类型（如 int、String），若不返回任何值，则使用 void
方法名：
自定义的标识符，遵循小驼峰命名法（如 calculateSum）
参数列表：
方法接收的输入参数，多个参数用逗号分隔（如 (int a, int b)），可以没有参数
方法体：
实现方法功能的代码块。
return 语句：
用于返回结果，必须与返回值类型匹配（void 方法可以省略）

方法调用的执行过程

具体过程如下：
调用方法 -> 传递参数 -> 找到方法地址 -> 执行被调用的方法主体 -> 被调方法结束返回 -> 回到主调方法继续往下执行

注意⚠️：
1.定义方法的时候，不会执行方法的代码，当方法被调用的时候才会执行
2.一个方法可以被多次调用

实参与形参的关系（重要）

1.基本概念
实参（实际参数）：方法调用时传递的具体值或引用
形参（形式参数）：方法定义时声明的参数，用于接收实参

2.基本数据类型的传递
机制：
传递的是实参值的副本，形参和实参在内存中存储于不同位置
形参地址：虚拟机栈中形参变量的地址
实参地址：调用方法的栈帧中实参变量的地址
两者地址不同，修改形参不会影响实参

3.引用数据类型的传递
机制：
传递的是实参引用（地址）的副本，形参和实参指向堆内存中的同一个对象
形参地址：虚拟机栈中形参变量的地址（存储对象引用）
实参地址：调用方法的栈帧中实参变量的地址（存储相同对象引用）
两者存储的引用值相同，指向同一对象，修改对象属性会影响实参

总结：

传递类型	实参与形参的地址关系	修改形参对实参的影响
基本类型	地址不同（栈中不同位置）	不影响实参值
引用类型	地址不同（栈中不同位置），但存储相同引用值	修改对象属性会影响实参指向的对象

方法重载

为什么需要方法重载

在 Java 中，方法重载（Method Overloading） 是指在同一个类中定义多个方法名相同但参数列表不同的方法。它的核心作用是用统一的方法名处理不同类型或数量的输入，从而提高代码的可读性、灵活性和易用性。

public class Calculator {
    // 两个整数相加
    public int add(int a, int b) {
        return a + b;
    }

    // 两个浮点数相加（参数类型不同）
    public double add(double a, double b) {
        return a + b;
    }

    // 三个整数相加（参数数量不同）
    public int add(int a, int b, int c) {
        return a + b + c;
    }

    // 整数和浮点数相加（参数顺序不同）
    public double add(int a, double b) {
        return a + b;
    }

    public static void main(String[] args) {
        Calculator calc = new Calculator();
        System.out.println(calc.add(2, 3));         // 调用int+int，输出5
        System.out.println(calc.add(2.5, 3.5));     // 调用double+double，输出6.0
        System.out.println(calc.add(1, 2, 3));      // 调用三个int，输出6
        System.out.println(calc.add(2, 3.5));       // 调用int+double，输出5.5
    }
}

总结：
方法重载的核心价值是用统一的名称封装相似功能，减少记忆成本，提升代码的可读性和易用性。它在实际开发中应用广泛（如构造方法、工具类方法等），是 Java 中简化代码逻辑的重要手段。

方法重载概念

概念：
在同一个类中，方法名相同但参数列表不同（参数类型、个数或顺序不同）的多个方法构成重载

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

    // 类型不同
    public double add(double a, double b) {
        return a + b;
    }

   // 数量不同
    public double add(int a,  int b， int c) {
        return a + b;
    }

   // 数量不同
    public double add(int b,  int a) {
        return a + b;
    }
}

关键规则：
1.方法名必须相同
2.参数列表必须不同（参数类型、个数、顺序至少有一项不同）
3.返回值类型和访问修饰符可以不同，但不能仅通过返回值或修饰符区分重载

递归

递归概念

在编程中，递归（Recursion） 是一种解决问题的方法，其核心思想是将问题分解为规模更小但结构相同的子问题，并通过自我调用来逐步解决这些子问题，直到达到终止条件。递归是计算机科学和数学中一种强大的抽象思维方式，常用于简化复杂问题的解决过程。

//计算阶乘
public static int factorial(int n) {
    // 终止条件
    if (n == 0 || n == 1) {
        return 1;
    }
    // 递推关系：n! = n × (n-1)!
    return n * factorial(n - 1);
}

总结：
递归是一种强大的编程技术，通过 “分而治之” 的思想将复杂问题简化。理解递归的核心要素（终止条件、递推关系）和执行过程，能帮助你在合适的场景下选择递归解决方案，同时避免常见的性能陷阱。

递归过程

递归过程是指递归函数从调用到返回结果的完整执行流程，通常分为递推和回归两个阶段。假如想理解递归过程，必须先理解清楚“方法的执行过程”，尤其是“方法结束后，回到调用位置继续往下执行”。

public class FactorialRecursion {
    // 递归计算阶乘
    public static int factorial(int n) {
        // 终止条件：n=0或n=1时，直接返回1
        if (n == 0 || n == 1) {
            return 1;
        }
        // 递推关系：n! = n × (n-1)!
        return n * factorial(n - 1);
    }

    public static void main(String[] args) {
        int num = 5;
        int result = factorial(num);
        System.out.println(num + "! = " + result); // 输出：5! = 120
    }
}

//递推
5! = 5 × 4!  
4! = 4 × 3!  
3! = 3 × 2!  
2! = 2 × 1!  
1! = 1 （触发终止条件，停止递推）

//回归
1! = 1  
2! = 2 × 1! = 2 × 1 = 2  
3! = 3 × 2! = 3 × 2 = 6  
4! = 4 × 3! = 4 × 6 = 24  
5! = 5 × 4! = 5 × 24 = 120  

总结：
阶乘的递归实现是递归思想的经典案例，其核心是利用 n! 与 (n-1)! 的递推关系，配合 0! = 1 的终止条件，将大问题逐步分解为小问题。通过这个例子，可以直观理解递归的 “递推 - 回归” 过程和栈帧管理机制。