Java方法(函数)
在之前的编程学习中，我们编写的程序都是将所有代码放在main方法中。虽然这样也能完成程序的功能，但当程序变得复杂时，所有的代码都混在一起，不仅难以理解，而且难以维护。
如果我们要建造一座房子，不可能把所有的材料都堆在一起。我们需要将房子分成不同的部分：地基、墙壁、屋顶、门窗等。每个部分都有特定的功能和结构。编程也是如此，我们需要将复杂的程序分解成小的、可管理的模块。
在Java中，这些模块称为方法。方法就像程序中的“小工具”，每个方法都有特定的功能，可以独立完成某个任务。
方法的基本概念
方法是由一组完成特定功能的语句组成的代码块。它可以接收外部传入的数据（称为参数），在方法内部对这些数据进行处理，执行一系列操作。
方法执行完毕后，可以选择将处理结果返回给调用者（通过返回值），也可以什么都不返回。我们可以把方法想象成一个“黑盒子”：你把需要处理的数据（参数）交给它，它在内部按照既定的步骤处理这些数据，然后把结果（如果有的话）返回出来。
这样做的好处是，方法内部的实现细节对外部是隐藏的，外部只需要知道如何使用这个方法，而不需要关心它是如何实现的。
方法的分类
Java中的方法可以分为两大类：
无返回值方法（void方法）：只执行任务，不返回任何值。就像你让某人去倒垃圾，他完成了任务，但没有带回任何东西。
有返回值方法：执行任务后，还会返回一个值。就像你让某人去买东西，他不仅完成了购买任务，还会把买到的商品带回来。
方法的组成部分
每个方法都有两个主要部分：
- 方法头：包含方法的修饰符、返回类型、方法名和参数列表
- 方法体：包含方法要执行的具体代码
让我们看一个简单的例子：
|public class MethodDemo { public static void main(String[] args) { System.out.println("程序开始"); // 调用无返回值方法 displayMessage(); // 调用有返回值方法 int result = addNumbers(5, 3); System.out.println("5 + 3 = " + result); System.out.println("程序结束"); } // 无返回值方法 public static void displayMessage() { System.out.println("这是一个无返回值方法"); System.out.println("它只执行任务，不返回任何值"); } // 有返回值方法 public static int addNumbers(int a, int b) { int sum = a + b; return sum; } }
运行这个程序会输出：
|程序开始 这是一个无返回值方法 它只执行任务，不返回任何值 5 + 3 = 8 程序结束
无返回值方法
无返回值方法的概念
无返回值方法（void方法）就像是一位“工人”，你可以让他去完成某项任务，但他完成后不会给你带回任何结果（即没有返回值）。这类方法的主要作用是执行某些操作，而不是计算并返回一个值。常见的无返回值方法用途包括：
- 显示信息：比如在控制台输出提示、打印欢迎语等。
- 打印数据：将变量、数组、表格等内容输出到屏幕上。
- 修改文件：执行写入文件、删除文件等操作，但不需要返回结果。
- 更新界面：在图形界面程序中，刷新界面、显示弹窗等。
- 执行一系列动作：比如初始化设置、清空数据、重置状态等。
无返回值方法通常用void关键字声明，表示该方法不返回任何数据。当你调用这种方法时，只会执行方法体中的代码，不会有任何值返回给调用者。即使方法内部有计算或处理，也不会通过return语句将结果带回主程序（但可以用return;单独结束方法的执行）。
举例来说，System.out.println()就是一个典型的无返回值方法：它负责把内容打印到控制台，但不会返回任何数据给你。
定义无返回值方法
无返回值方法的语法如下：
|public static void 方法名() { // 方法体 - 要执行的代码 }
第一个无返回值方法示例
让我们创建一个简单的无返回值方法：
|public class VoidMethodDemo { public static void main(String[] args) { System.out.println("主方法开始"); // 调用无返回值方法 showGreeting(); showCurrentTime(); System.out.println("主方法结束"); } // 显示问候语的方法 public static void showGreeting() { System.out.println("你好！欢迎学习Java方法！"); System.out.println("今天是个好日子！"); } // 显示当前时间的方法 public static void showCurrentTime() { System.out.println("当前时间是：" + java.time.LocalTime.now()); } }
运行这个程序会输出：
|主方法开始 你好！欢迎学习Java方法！ 今天是个好日子！ 当前时间是：14:30:25.123 主方法结束
方法的调用过程
让我们详细分析一下方法是如何被调用的：
- 程序开始：从main方法开始执行
- 方法调用：遇到方法调用语句时，程序跳转到该方法
- 执行方法体：执行方法中的代码
- 返回调用点：方法执行完毕后，返回到调用它的地方继续执行
在控制结构中使用方法
方法调用不仅可以在主方法中直接使用，还可以灵活地嵌入到各种控制结构中，例如循环（如for、while）、条件语句（如if-else、switch）等。 通过在这些结构中调用方法，可以让程序结构更加清晰、代码更加复用。例如，我们可以在循环中多次调用同一个方法，或者在不同的条件下调用不同的方法，从而实现更复杂的逻辑。
|public class MethodInControlStructures { public static void main(String[] args) { // 在循环中调用方法 for (int i = 1; i <= 3; i++) { System.out.println("第" + i + "次调用："); showMessage(); } // 在条件语句中调用方法 int score = 85; if (score >= 60) { showPassMessage(); } else { showFailMessage(); } } public static void showMessage() { System.out.println("这是一个方法调用"); } public static void showPassMessage() { System.out.println("恭喜！你通过了考试！"); } public static void showFailMessage() { System.out.println("很遗憾，你需要重新考试。"); } }
运行这个程序会输出：
|第1次调用： 这是一个方法调用 第2次调用： 这是一个方法调用 第3次调用： 这是一个方法调用 恭喜！你通过了考试！
向方法传递参数
参数的概念
在编写方法时，很多情况下我们希望方法能够根据不同的输入数据执行不同的操作。为了实现这一点，我们可以在方法定义时指定参数（parameter），这样在调用方法时就可以将不同的数据传递给方法。 方法内部可以使用这些参数来完成相应的逻辑处理。简单来说，参数就是方法用来接收外部传入数据的“占位符”，通过传递不同的参数，方法的行为也会随之变化。
参数和实参的区别
-
参数（Parameter）：参数是在方法定义时声明的变量，用于接收外部传入的数据。它们就像是方法的“占位符”，在方法体内部可以像普通变量一样使用。例如：
|public static void greet(String name) { System.out.println("你好，" + name); }这里的
String name就是参数。 -
实参（Argument）：实参是在调用方法时实际传递给方法的数据。实参可以是常量、变量、表达式等。方法调用时，实参的值会被赋给对应的参数。例如：
|greet("小明"); // "小明" 是实参 String user = "小红"; greet(user); // 变量 user 的值作为实参传递 greet("小" + "王"); // 表达式 "小" + "王" 的结果作为实参传递在上面的例子中，每次调用
greet方法时，括号中的内容就是实参，它们会被传递给方法定义中的参数name。
单参数方法
有时候，我们希望方法能够根据传入的数据执行不同的操作。这时，可以为方法定义参数。下面我们通过一个例子，详细说明如何编写一个接收单个参数的方法，以及如何以不同方式传递参数给它：
|public class SingleParameterDemo { public static void main(String[] args) { // 调用方法并传递不同的参数 displayNumber(10); displayNumber(25); displayNumber(100); // 传递变量作为参数 int myNumber = 42; displayNumber(myNumber); // 传递表达式作为参数 displayNumber(5 + 3); } // 接收一个整数参数的方法 public static void displayNumber(int num) { System.out.println("你传递的数字是：" + num); } }
运行这个程序会输出：
|你传递的数字是：10 你传递的数字是：25 你传递的数字是：100 你传递的数字是：42 你传递的数字是：8
多参数方法
方法也可以接收多个参数。下面我们通过一个例子，详细说明如何编写一个接收多个参数的方法，以及如何以不同方式传递参数给它：
|public class MultipleParametersDemo { public static void main(String[] args) { // 调用多参数方法 showSum(5, 10); showSum(20, 30); // 传递变量 int a = 15; int b = 25; showSum(a, b); // 传递表达式 showSum(a + 5, b - 5); } // 接收两个参数的方法 public static void showSum(int num1, int num2) { int sum = num1 + num2; System.out.println(num1 + " + " + num2 + " = " + sum); } }
运行这个程序会输出：
|5 + 10 = 15 20 + 30 = 50 15 + 25 = 40 20 + 20 = 40
参数的数据类型
参数也可以是任何数据类型：
|public class DataTypeParametersDemo { public static void main(String[] args) { // 传递不同类型的参数 displayInfo("张三", 25, 1.75); displayInfo("李四", 30, 1.80); // 传递布尔值 checkAge(18); checkAge(15); } // 接收不同类型参数的方法 public static void displayInfo(String name, int age, double height) { System.out.println("姓名：" + name); System.out.println("年龄：" + age); System.out.println("身高：" + height + "米"); System.out.println("----------------"); } // 接收布尔值参数的方法 public static void checkAge(int age) { boolean isAdult = age >= 18; System.out.println("年龄：" + age + "，是否成年：" + isAdult); } }
运行这个程序会输出：
|姓名：张三 年龄：25 身高：1.75米 ---------------- 姓名：李四 年龄：30 身高：1.8米 ---------------- 年龄：18，是否成年：true 年龄：15，是否成年：false
参数传递的注意事项
在编写方法时，需要注意以下几点：
- 数据类型匹配：传递的参数类型必须与方法参数类型兼容
- 参数顺序：传递参数时必须按照方法定义的顺序
- 参数数量：传递的参数数量必须与方法定义的参数数量一致
局部变量
局部变量的概念
局部变量是指在方法内部声明的变量。它们的作用范围（也叫“作用域”）仅限于当前方法的代码块内。也就是说：
- 局部变量只能在声明它们的方法中被访问和使用，方法外部无法直接访问这些变量。
- 当方法执行到声明局部变量的那一行时，变量才会被创建；当方法执行结束后，这些局部变量就会被销毁，内存空间也会被释放。
- 不同方法中可以声明同名的局部变量，它们互不影响，各自独立。
- 局部变量在使用前必须先赋值，否则编译器会报错。
局部变量的作用域
|public class LocalVariableDemo { public static void main(String[] args) { // main方法的局部变量 int mainVariable = 10; System.out.println("main方法中的变量：" + mainVariable); // 调用其他方法 method1(); method2(); // 注意：这里无法访问method1和method2中的局部变量 // System.out.println(method1Variable); // 错误！ } public static void method1() { // method1的局部变量 int method1Variable = 20; System.out.println("method1中的变量：" + method1Variable); } public static void method2() { // method2的局部变量，可以与method1中的变量同名 int method1Variable = 30; // 这是不同的变量 System.out.println("method2中的变量：" + method1Variable); } }
运行这个程序会输出：
|main方法中的变量：10 method1中的变量：20 method2中的变量：30
局部变量的生命周期
局部变量的生命周期非常短暂：它们只在方法执行的过程中存在。当方法被调用时，局部变量才会被创建并分配内存；当方法执行结束后，这些局部变量就会被销毁，所占用的内存空间也会被释放。每次调用方法时，都会重新创建一份新的局部变量，彼此互不影响。因此，局部变量无法在方法外部访问，也不会在多次方法调用之间保留其值。
|public class VariableLifetimeDemo { public static void main(String[] args) { System.out.println("第一次调用方法："); countCalls(); System.out.println("第二次调用方法："); countCalls(); System.out.println("第三次调用方法："); countCalls(); } public static void countCalls() { int callCount = 0; // 每次调用方法时都会重新创建 callCount++; System.out.println("这是第" + callCount + "次调用"); } }
运行这个程序会输出：
|第一次调用方法： 这是第1次调用 第二次调用方法： 这是第1次调用 第三次调用方法： 这是第1次调用
有返回值方法
有返回值方法的概念
有返回值的方法不仅仅是执行某项任务，还会在任务完成后，将一个结果（返回值）交还给调用它的代码。你可以把它想象成餐厅里的“服务员”：你下单后，服务员不仅会帮你把菜点好，还会把做好的菜端到你面前。具体来说，有返回值的方法在执行完毕后，会通过return语句把一个值返回给调用者，这个值可以是任意类型（如int、double、String等），并且可以被赋值给变量、参与表达式运算，或者直接用于输出。这样，调用者就能根据方法返回的结果进行后续操作，实现更灵活和强大的程序逻辑。
定义有返回值方法
有返回值方法的语法如下：
|public static 返回类型 方法名(参数列表) { // 方法体 return 返回值; }
第一个有返回值方法示例
|public class ReturnValueDemo { public static void main(String[] args) { // 调用有返回值方法 int result1 = add(5, 3); System.out.println("5 + 3 = " + result1); int result2 = multiply(4, 6); System.out.println("4 × 6 = " + result2); double result3 = divide(10, 3); System.out.println("10 ÷ 3 = " + result3); // 在表达式中使用返回值 int total = add(5, 3) + multiply(2, 4); System.out.println("总结果：" + total); } // 返回两个数的和 public static int add(int a, int b) { int sum = a + b; return sum; } // 返回两个数的积 public static int multiply(int a, int b) { return a * b; // 可以直接返回表达式 } // 返回两个数的商 public static double divide(int a, int b) { return (double) a / b; } }
运行这个程序会输出：
|5 + 3 = 8 4 × 6 = 24 10 ÷ 3 = 3.3333333333333335 总结果：16
返回不同类型的值
在Java中，方法不仅可以返回基本数据类型（如int、double、char、boolean等），还可以返回引用类型（如String、数组、对象等）。这意味着你可以根据实际需求，让方法返回任意类型的数据。例如：
- 返回基本类型：如int、double、boolean等，常用于数值计算、状态判断等场景。
- 返回字符串（String）：常用于拼接和处理文本信息。
- 返回字符（char）：适合单个字符的判断或处理。
- 返回布尔值（boolean）：用于条件判断，表示真假、是否等。
- 返回数组：可以一次性返回一组数据，适合批量处理。
- 返回对象：可以将复杂的数据结构或多个相关数据通过对象封装后返回，便于后续操作和扩展。
下面通过代码示例详细演示方法如何返回不同类型的数据。
|public class DifferentReturnTypesDemo { public static void main(String[] args) { // 返回字符串 String fullName = getFullName("张", "三"); System.out.println("全名：" + fullName); // 返回布尔值 boolean isAdult = checkAge(20); System.out.println("是否成年：" + isAdult); // 返回字符 char grade = getGrade(85); System.out.println("成绩等级：" + grade); } // 返回字符串 public static String getFullName(String firstName, String lastName) { return firstName + lastName; } // 返回布尔值 public static boolean checkAge(int age) { return age >= 18; } // 返回字符 public static char getGrade(int score) { if (score >= 90) return 'A'; else if (score >= 80) return 'B'; else if (score >= 70) return 'C'; else if (score >= 60) return 'D'; else return 'F'; } }
运行这个程序会输出：
|全名：张三 是否成年：true 成绩等级：B
返回对象引用
方法也可以返回对象的引用。下面我们通过一个例子，详细说明如何编写一个返回对象引用的方法，以及如何使用这个返回值：
|import java.time.LocalDateTime; public class ObjectReturnDemo { public static void main(String[] args) { // 返回当前时间 LocalDateTime now = getCurrentTime(); System.out.println("当前时间：" + now); // 返回问候语 String greeting = getGreeting("张三"); System.out.println(greeting); } // 返回当前时间对象 public static LocalDateTime getCurrentTime() { return LocalDateTime.now(); } // 返回问候语字符串 public static String getGreeting(String name) { return "你好，" + name + "！欢迎学习Java！"; } }
方法的重用
代码重用的概念
方法的一个重要优势是代码重用。所谓代码重用，就是将一段实现特定功能的代码封装成方法（函数），这样在需要这个功能的地方，只需调用方法即可，无需每次都重新编写相同的实现细节。 这不仅大大减少了代码的重复，提高了开发效率，还让程序结构更加清晰、易于维护和修改。
举例来说，如果你需要在程序的多个地方进行加法运算，只需编写一个加法方法，然后在不同的位置调用它即可。 如果将来加法的实现需要调整，只需修改方法本身，所有调用该方法的地方都会自动获得最新的实现，无需逐一修改。这种方式极大地提升了代码的灵活性和可维护性。
此外，方法的重用还可以让大型程序的开发变得更加协作和模块化。不同的开发者可以分别负责不同的方法，各自实现和测试自己的功能，最后通过方法调用将各个部分组合成完整的系统。
实际应用示例
让我们创建一个简单的计算器程序，展示方法的重用：
|public class CalculatorDemo { public static void main(String[] args) { // 使用相同的计算方法进行不同的计算 int result1 = add(10, 20); int result2 = add(5, 15); int result3 = add(100, 200); System.out.println("10 + 20 = " + result1); System.out.println("5 + 15 = " + result2); System.out.println("100 + 200 = " + result3); // 使用乘法方法 int product1 = multiply(4, 5); int product2 = multiply(6, 7); System.out.println("4 × 5 = " + product1); System.out.println("6 × 7 = " + product2); // 组合使用 int complexResult = add(multiply(2, 3), multiply(4, 5)); System.out.println("(2×3) + (4×5) = " + complexResult); } // 加法方法 public static int add(int a, int b) { return a + b; } // 乘法方法 public static int multiply(int a, int b) { return a * b; } }
运行这个程序会输出：
|10 + 20 = 30 5 + 15 = 20 100 + 200 = 300 4 × 5 = 20 6 × 7 = 42 (2×3) + (4×5) = 26
方法的层次调用
方法调用方法
在Java中，一个方法不仅可以独立完成某项任务，还可以在其内部调用其他方法，从而形成“层次化”的调用结构。
这种结构类似于公司中的管理层级：上层方法负责整体流程的把控，下层方法各自专注于具体的细节处理。通过方法之间的相互调用，可以将复杂的问题拆解为多个小的、易于管理的步骤，每个方法只关注自己的职责。
例如，主方法（main）可以调用一个数据处理方法，而数据处理方法又可以进一步调用输入验证、结果计算、结果展示等子方法。这样做的好处是让代码结构更加清晰、易于维护和扩展，也方便团队协作开发。
|public class MethodHierarchyDemo { public static void main(String[] args) { System.out.println("开始主程序"); // 主方法调用第一层方法 processData(); System.out.println("主程序结束"); } // 第一层方法 public static void processData() { System.out.println("进入数据处理方法"); // 调用第二层方法 validateInput(); calculateResult(); displayOutput(); System.out.println("数据处理完成"); } // 第二层方法 public static void validateInput() { System.out.println("验证输入数据"); } public static void calculateResult() { System.out.println("计算结果"); } public static void displayOutput() { System.out.println("显示输出结果"); } }
运行这个程序会输出：
|开始主程序 进入数据处理方法 验证输入数据 计算结果 显示输出结果 数据处理完成 主程序结束
方法的文档注释
前面我们简单介绍了注释的作用，但在实际开发中，普通注释往往无法全面表达方法的用途、参数、返回值以及注意事项。 此时，良好的文档注释（如Javadoc注释）就显得尤为重要。通过为每个方法编写详细的文档注释，不仅可以让其他程序员（包括未来的你）快速理解方法的功能、 输入参数、返回值类型和可能的异常，还能提升代码的可维护性和可读性。
文档注释还能被自动化工具提取生成API文档，方便团队协作和后续开发。因此，养成为方法编写规范、详细的文档注释的习惯，是高质量Java编程的重要一环。
使用@param和@return标签
|/** * 计算两个数的和 * @param a 第一个数 * @param b 第二个数 * @return 两个数的和 */ public static int add(int a, int b) { return a + b; } /** * 检查年龄是否成年 * @param age 要检查的年龄 * @return 如果年龄大于等于18返回true，否则返回false */ public static boolean isAdult(int age) { return age >= 18; }
习题
- 在Java中，无返回值方法使用哪个关键字声明？
- 方法定义中，用于接收外部传入数据的部分是？
- 在Java中，有返回值方法如何返回值？
- 在方法内部声明的变量，只能在该方法内使用的变量称为？
- 调用方法时，必须与方法定义匹配的是？
- 以下哪个是无返回值方法的正确定义？
- 以下哪个是接收两个整数参数的方法的正确定义？
8. 无返回值方法练习
编写一个方法，显示个人信息（姓名、年龄、职业），并在main方法中调用它。
|public class PersonalInfoDemo { public static void main(String[] args) { // 调用方法显示个人信息 showPersonalInfo("张三", 25, "程序员"); showPersonalInfo("李四", 30, "教师"); } // 无返回值方法，显示个人信息 public static void showPersonalInfo(String name, int age, String job) { System.out.println("姓名: " + name); System.out.println("年龄: " + age); System.out.println("职业: " + job); System.out.println("----------------"); } }
输出结果：
|姓名: 张三 年龄: 25 职业: 程序员 ---------------- 姓名: 李四 年龄: 30 职业: 教师 ----------------
说明：
showPersonalInfo是无返回值方法（void）- 方法接收三个参数：姓名、年龄、职业
- 在方法体内打印个人信息
- 可以在main方法中多次调用，传递不同的参数
9. 有返回值方法练习
编写一个方法，计算圆的面积（接收半径参数，返回面积），并在main方法中使用返回值。
|public class CircleAreaDemo { public static void main(String[] args) { // 调用方法并接收返回值 double area1 = calculateCircleArea(5.0); System.out.println("半径为5.0的圆的面积: " + area1); double area2 = calculateCircleArea(10.0); System.out.println("半径为10.0的圆的面积: " + area2); // 在表达式中使用返回值 double totalArea = calculateCircleArea(3.0) + calculateCircleArea(4.0); System.out.println("两个圆的面积和: " + totalArea); } // 有返回值方法，计算圆的面积 public static double calculateCircleArea(double radius) { double area = 3.14159 * radius * radius; return area; } }
输出结果：
|半径为5.0的圆的面积: 78.53975 半径为10.0的圆的面积: 314.159 两个圆的面积和: 39.26991
说明：
calculateCircleArea是有返回值方法，返回类型为double- 方法接收一个
double类型的参数（半径） - 使用
return语句返回计算结果 - 调用方法时可以将返回值赋给变量或用于表达式
10. 多参数方法练习
编写一个方法，计算三个数的最大值，并在main方法中调用它。
|public class MaxValueDemo { public static void main(String[] args) { // 调用方法计算最大值 int max1 = findMax(10, 25, 15); System.out.println("10, 25, 15中的最大值: " + max1); int max2 = findMax(5, 3, 8); System.out.println("5, 3, 8中的最大值: " + max2); // 传递变量作为参数 int a = 100; int b = 200; int c = 150; int max3 = findMax(a, b, c); System.out.println(a + ", " + b + ", " + c + "中的最大值: " + max3); } // 多参数方法，计算三个数的最大值 public static int findMax(int num1, int num2, int num3) { int max = num1; if (num2 > max) { max = num2; } if (num3 > max) { max = num3; } return max; } }
输出结果：
|10, 25, 15中的最大值: 25 5, 3, 8中的最大值: 8 100, 200, 150中的最大值: 200
说明：
findMax方法接收三个int类型的参数- 使用if语句比较三个数，找出最大值
- 返回最大值
- 可以传递常量、变量或表达式作为参数
11. 方法调用练习
编写一个程序，使用多个方法完成简单的计算器功能（加法、减法、乘法、除法）。
|public class CalculatorDemo { public static void main(String[] args) { int a = 20; int b = 5; // 调用不同的计算方法 int sum = add(a, b); int difference = subtract(a, b); int product = multiply(a, b); double quotient = divide(a, b); // 显示结果 System.out.println(a + " + " + b + " = " + sum); System.out.println(a + " - " + b + " = " + difference); System.out.println(a + " × " + b + " = " + product); System.out.println(a + " ÷ " + b + " = " + quotient); } // 加法方法 public static int add(int x, int y) { return x + y; } // 减法方法 public static int subtract(int x, int y) { return x - y; } // 乘法方法 public static int multiply(int x, int y) { return x * y; } // 除法方法 public static double divide(int x, int y) { return (double) x / y; } }
输出结果：
|20 + 5 = 25 20 - 5 = 15 20 × 5 = 100 20 ÷ 5 = 4.0
说明：
- 定义了四个方法，分别实现加、减、乘、除
- 每个方法都有明确的职责（单一职责原则）
- 在main方法中调用这些方法完成计算
- 方法可以被多次调用，实现代码重用