Java基础快速入门: 方法详解

本文纲要

1. 方法概述
2. 方法的定义和调用
3. 方法调用过程（内存图）
4. 带参数的方法
5. 形参和实参
6. 带返回值的方法
7. 方法通用格式
8. 方法注意事项
9. 方法重载
10. 方法参数传递
    基本数据类型
    引用数据类型
11. 综合练习
    数组遍历
    获取数组最大值
    同时获取数组最大值和最小值

方法概述

在 Java 中，方法（Method） 是一段具有独立功能的代码块，只有被调用时才会执行。方法可以显著提高代码的复用性，减少重复代码

举个例子：在植物大战僵尸游戏中，多个植物都具备发射炮弹的功能，如果每个植物都写一遍相同的代码，会造成大量重复。此时可以把发射炮弹的代码抽取到一个公共区域，每个植物需要时去调用即可。这个公共区域中的代码就是方法

方法的优点：

• 提高代码复用性
• 降低代码冗余度
• 便于维护和扩展

方法的使用原则：

• 必须先定义，后调用。
• 不调用不执行，定义后不会自动运行

方法的定义和调用

1 ） 定义格式

public static void 方法名() {
    // 方法体：真正要执行的逻辑代码 
}

方法名需要符合标识符命名规范，方法体中可以编写任意合法的 Java 代码

2 ) 调用格式

方法名();

方法之间是平级关系，不能嵌套定义。即不能在一个方法内部再定义另一个方法，但可以在一个方法内部调用另一个方法

3 ) 示例代码

public class Demo1Method {
    public static void main(String[] args) {
        eat(); // 调用eat方法
    }
 
    public static void eat() {
        study(); // 在eat方法中调用study方法 
        System.out.println("吃饭");
    }
 
    public static void study() {
        System.out.println("学习");
    }
}

运行结果：

学习
吃饭

注意：方法调用不限于 main 方法，可以在任何方法中调用其他方法。main 方法是程序的入口，一般从这里开始调用

方法调用过程（内存图）

方法未被调用时，存储在方法区的字节码文件中。当方法被调用时，会加载到栈内存中执行。栈内存的特点：先进后出（类似弹匣）
简单调用过程

1. 虚拟机调用 main 方法，main 压入栈内存
2. main 调用 eat，eat 压入栈内存，执行 eat 中的代码
3. eat 执行完毕，弹出栈内存
4. main 继续执行，最后弹出栈内存，程序结束
   复杂调用过程（eat内部调用study和sleep）

随着方法调用，栈帧依次压入和弹出，体现了栈内存的先进后出特性

带参数的方法

1 ) 为什么需要参数

如果方法需要处理外部传入的数据，就需要使用参数。例如，判断一个数是奇数还是偶数，这个数不能写死在方法内部，而是由调用者提供，这样方法更灵活

2 ) 定义与调用格式

定义格式：

public static void 方法名(数据类型 变量名) {
    // 方法体，可以使用变量名
}

多个参数之间用逗号分隔

调用格式：

方法名(实际参数);

实际参数可以是常量，也可以是变量，类型和数量必须与方法定义中的参数匹配

3 ) 示例：判断奇偶数

public class Demo1Method {
    public static void main(String[] args) {
        isEvenNumber(10); // 传入具体数值
        isEvenNumber(11);
    }
 
    public static void isEvenNumber(int num) {
        if (num % 2 == 0) {
            System.out.println("偶数");
        } else {
            System.out.println("奇数");
        }
    }
}

4 ) 练习：打印 n 到 m 之间的奇数

需求：设计一个方法 print，接收两个整数 n 和 m，打印 n 到 m 之间所有的奇数

初始版本（存在缺陷）：

public static void print(int n, int m) {
    System.out.println(n + "到" + m + "之间的奇数为:");
    for (int i = n; i <= m; i++) {
        if (i % 2 == 1) {
            System.out.println(i);
        }
    }
}

如果调用时 n > m，循环条件不成立，不会输出任何奇数，并且提示信息不友好

改进版本： 增加健壮性判断，如果参数不合理，直接提示并结束方法

public static void print(int n, int m) {
    if (m < n) {
        System.out.println("您传入的数据有误，请检查");
        return; // 结束方法，不再执行后续代码
    }
    System.out.println(n + "到" + m + "之间的奇数为:");
    for (int i = n; i <= m; i++) {
        if (i % 2 == 1) {
            System.out.println(i);
        }
    }
}

return; 在 void 方法中可以直接结束方法，后续代码不会执行

形参和实参

形参（形式参数）：方法定义时声明的参数变量，如 int num
实参（实际参数）：方法调用时传入的具体数值或变量，如 10 或 a

形参只有在方法被调用时才被赋值，否则只是形式上的占位符。

带返回值的方法

1 ) 为什么需要返回值

有些方法需要将计算结果返回给调用者，以便后续使用，而不是仅仅打印到控制台。这时就需要定义带返回值的方法。

2 ) 定义与调用格式

定义格式：

public static 返回值类型 方法名(参数列表) {
    // 方法体
    return 返回值; // 返回值类型必须与方法声明中的返回值类型匹配 
}

调用格式：

返回值类型 变量 = 方法名(实参);

如果不接收返回值，方法执行的结果将无法被使用。

3 ) 示例：求两个整数之和

public class Demo1Method {
    public static void main(String[] args) {
        int sum = add(10, 20);
        System.out.println(sum); // 输出30
    }
 
    public static int add(int a, int b) {
        int c = a + b;
        return c;
    }
}

4 ) 练习：求两个数的最大值

public class Demo2Method {
    public static void main(String[] args) {
        // 调用方式1：输出调用，仅打印结果
        System.out.println(getMax(10, 20));
 
        // 调用方式2：变量接收，可以继续使用结果 
        int max = getMax(10, 20);
        System.out.println(max);
        for (int i = 1; i <= max; i++) {
            System.out.println("HelloWorld");
        }
    }
 
    public static int getMax(int a, int b) {
        if (a > b) {
            return a;
        } else {
            return b;
        }
    }
}

推荐使用变量接收返回值，这样结果可以参与后续运算。

方法通用格式

public static 返回值类型 方法名(参数列表) {
    // 方法体 
    return 返回值;
}

各部分说明：

• public static：修饰符，目前固定格式。
• 返回值类型：方法返回结果的数据类型，如果没有返回值，写 void。
• 方法名：符合标识符命名规范，调用时使用。
• 参数列表：方法运行前需要的材料，由数据类型和变量名组成，多个参数用逗号分隔。
• 方法体：完成功能的代码。
• return：将结果返回给调用者，void 方法中可以省略，或使用 return; 直接结束方法。

定义方法前需要明确：

1. 参数：是否需要材料？需要几个？什么类型？
2. 返回值类型：方法执行后是否有结果返回？是什么类型？

方法注意事项

1. 方法不能嵌套定义。
2. void 方法中，return 可省略；若写 return，后面不能接数据。
3. return 语句之后不能再写代码，因为无法执行到。

示例：

// 正确：void方法无返回值，省略return
public static void methodA() {
    System.out.println("Hello");
}
 
// 正确：void方法使用return;结束
public static void methodB() {
    if (condition) {
        return;
    }
    System.out.println("Hello");
}
 
// 错误：void方法return后不能有数据 
public static void methodC() {
    return 100; // 编译错误
}
 
// 错误：return后不能有代码 
public static int methodD() {
    return 1;
    System.out.println("无法执行"); // 编译错误
}

方法重载

方法重载（Overload）：在同一个类中，方法名相同，但参数列表不同（个数、类型、顺序不同），这些方法构成重载关系。与返回值类型无关。

1 ) 重载的好处

例如 System.out.println 可以接收各种类型的数据，就是因为它有很多重载方法，我们不需要记忆多个方法名。

2 ) 示例：比较两个整数是否相同（兼容全整数类型）

public class Demo1Overload {
    public static void main(String[] args) {
        short a = 10;
        short b = 20;
        System.out.println(compare(a, b));
    }
 
    public static boolean compare(int a, int b) {
        return a == b;
    }
    public static boolean compare(byte a, byte b) {
        return a == b;
    }
    public static boolean compare(short a, short b) {
        return a == b;
    }
    public static boolean compare(long a, long b) {
        return a == b;
    }
}

四个方法名相同，参数类型不同，构成重载。调用时根据实参类型自动匹配对应的方法。

方法参数传递

1 ) 基本数据类型

基本数据类型作为参数时，传递的是具体数值，形参的改变不影响实参。

public class Test1 {
    public static void main(String[] args) {
        int number = 100;
        System.out.println("调用change方法前:" + number); // 100
        change(number);
        System.out.println("调用change方法后:" + number); // 100 
    }
 
    public static void change(int number) {
        number = 200; // 修改的是形参，不影响实参
    }
}

内存分析：main 中的 number 和 change 中的形参 number 是两个不同的变量，传递的只是数值 100 的副本。

2 ) 引用数据类型

引用数据类型作为参数时，传递的是内存地址，因此形参可以通过地址修改堆内存中的数据，从而影响实参。

public class Test2 {
    public static void main(String[] args) {
        int[] arr = {10, 20, 30};
        System.out.println("调用change方法前:" + arr[1]); // 20
        change(arr);
        System.out.println("调用change方法后:" + arr[1]); // 200
    }
 
    public static void change(int[] arr) {
        arr[1] = 200; // 修改堆内存中的数据，会影响原数组
    }
}

内存分析：main 中的 arr 和 change 中的形参 arr 存储的是同一个数组的地址，指向同一块堆内存空间，因此修改会相互影响。

综合练习

1 ) 数组遍历

设计一个方法，将数组元素以格式 [11, 22, 33, 44, 55] 输出到一行。

public class Test1 {
    public static void main(String[] args) {
        int[] arr = {11, 22, 33, 44, 55};
        printArray(arr);
        System.out.println("另外一段代码逻辑");
    }
 
    public static void printArray(int[] arr) {
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length - 1) {
                // 最后一个元素，特殊处理，加上右括号并换行
                System.out.println(arr[i] + "]");
            } else {
                // 非最后一个元素，拼接逗号空格，不换行 
                System.out.print(arr[i] + ", ");
            }
        }
    }
}

2 ) 获取数组最大值

设计一个方法，返回数组中的最大值。

public class Test2 {
    public static void main(String[] args) {
        int[] arr = {11, 55, 22, 44, 33};
        int max = getMax(arr);
        System.out.println(max); // 55 
    }
 
    public static int getMax(int[] arr) {
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (max < arr[i]) {
                max = arr[i];
            }
        }
        return max;
    }
}

3 ) 同时获取数组最大值和最小值

return 语句只能返回一个结果，如果需要同时返回多个值，可以将它们放入数组等容器中返回。

public class Test3 {
    public static void main(String[] args) {
        int[] arr = {11, 55, 33, 22, 44};
        int[] maxAndMin = getMaxAndMin(arr);
        System.out.println("最小值：" + maxAndMin[0]); // 11 
        System.out.println("最大值：" + maxAndMin[1]); // 55
    }
 
    public static int[] getMaxAndMin(int[] arr) {
        int max = arr[0];
        int min = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
            if (arr[i] < min) {
                min = arr[i];
            }
        }
        // 将最大值和最小值存入数组返回
        int[] result = {min, max};
        return result;
    }
}

通过以上内容，我们掌握了 Java 方法的核心知识，包括定义、调用、参数、返回值、重载以及参数传递机制。这些是编写结构化、可复用代码的基础，后续的面向对象编程将在此基础上进一步深入。