函数（方法）是Java程序的基本组成单元，是组织代码、实现逻辑复用、降低复杂度的核心手段。从面向对象编程中的实例方法，到Java 8引入的函数式编程特性，Java的函数体系经历了从严格面向对象到拥抱函数式编程的演进。本文将系统全面地梳理Java函数的核心知识点，从基础语法到高级特性，帮助初学者建立完整的知识体系，也为有经验的开发者提供深入的技术参考。
一、函数基础
1.1 什么是函数
函数（Method） 是执行特定任务的代码块，是Java程序的最小执行单元。在面向对象编程中，函数通常被称为方法，它定义了对象的行为。
核心概念：
方法签名：方法名 + 参数列表
方法体：包含具体执行逻辑的代码块
返回值：方法执行后返回的结果
参数：传递给方法的数据
1.2 方法声明语法
[修饰符] 返回值类型 方法名([参数列表]) [throws 异常类型] {
// 方法体
[return 返回值;]
}
示例：
public class MethodDemo {
// 无参数无返回值的方法
public void sayHello() {
System.out.println("Hello, World!");
}
// 带参数无返回值的方法
public void greet(String name) {
System.out.println("Hello, " + name);
}
// 带返回值的方法
public int add(int a, int b) {
return a + b;
}
// 带多个参数和返回值的方法
public static int multiply(int a, int b) {
return a * b;
}
}
1.3 方法修饰符
1.4 返回值类型
public class ReturnTypeDemo {
// 基本类型返回值
public int getInt() {
return 42;
}
// 引用类型返回值
public String getString() {
return "Hello";
}
// 数组返回值
public int[] getArray() {
return new int[]{1, 2, 3};
}
// 泛型返回值
public <T> T getValue(T value) {
return value;
}
// void - 无返回值
public void doNothing() {
// 可以省略 return
// 或使用 return; 提前退出
}
// 返回Optional
public Optional<String> findName(Long id) {
return Optional.ofNullable(userMap.get(id));
}
}
二、参数传递
2.1 形参与实参
public class ParameterDemo {
// 形参：方法定义时的参数
public void printMessage(String message) { // message是形参
System.out.println(message);
}
public void demo() {
// 实参：方法调用时传入的实际值
printMessage("Hello"); // "Hello"是实参
}
}
2.2 值传递 vs 引用传递
Java总是采用值传递：
基本类型：传递值的副本
引用类型：传递引用的副本（即地址值的副本）
public class PassByValueDemo {
// 基本类型：修改不影响原变量
public void changeInt(int num) {
num = 100; // 修改的是副本
}
// 引用类型：修改对象属性会影响原对象
public void changePerson(Person p) {
p.setName("New Name"); // 修改对象属性
}
// 引用类型：重新赋值不影响原引用
public void reassignPerson(Person p) {
p = new Person("New Person"); // 修改的是副本引用
}
public void demo() {
int a = 10;
changeInt(a);
System.out.println(a); // 输出: 10（未改变）
Person person = new Person("张三");
changePerson(person);
System.out.println(person.getName()); // 输出: New Name（属性改变）
reassignPerson(person);
System.out.println(person.getName()); // 输出: New Name（引用未变）
}
}
2.3 参数类型
public class ParameterTypesDemo {
// 1. 基本类型参数
public void primitiveParams(int a, double b, boolean c) {
// 基本类型
}
// 2. 引用类型参数
public void referenceParams(String str, List<String> list, Map<String, Object> map) {
// 引用类型
}
// 3. 可变参数（varargs）
public void varargsMethod(String... args) {
for (String arg : args) {
System.out.println(arg);
}
}
// 可变参数必须是最后一个参数
public void mixedParams(String prefix, int... numbers) {
System.out.println("Prefix: " + prefix);
for (int num : numbers) {
System.out.println(num);
}
}
// 4. 数组参数
public void arrayParams(int[] arr) {
for (int i : arr) {
System.out.println(i);
}
}
// 5. 函数式接口参数（Java 8+）
public void functionalParam(Supplier<String> supplier, Consumer<Integer> consumer) {
String result = supplier.get();
consumer.accept(result.length());
}
// 使用示例
public void demo() {
varargsMethod("a", "b", "c");
mixedParams("Numbers:", 1, 2, 3, 4, 5);
functionalParam(
() -> "Hello World",
len -> System.out.println("Length: " + len)
);
}
}
三、方法重载
3.1 重载概念
方法重载（Overloading）：同一个类中，多个方法具有相同的名称但不同的参数列表。
重载规则：
方法名必须相同
参数列表必须不同（参数个数、类型、顺序）
返回值类型可以相同也可以不同（但不能仅靠返回值区分）
访问修饰符可以不同
public class OverloadDemo {
// 1. 参数个数不同
public void print() {
System.out.println("无参数");
}
public void print(String msg) {
System.out.println("一个参数: " + msg);
}
public void print(String msg1, String msg2) {
System.out.println("两个参数: " + msg1 + ", " + msg2);
}
// 2. 参数类型不同
public void display(int num) {
System.out.println("整数: " + num);
}
public void display(String str) {
System.out.println("字符串: " + str);
}
public void display(double num) {
System.out.println("浮点数: " + num);
}
// 3. 参数顺序不同
public void setInfo(String name, int age) {
System.out.println("姓名: " + name + ", 年龄: " + age);
}
public void setInfo(int age, String name) {
System.out.println("年龄: " + age + ", 姓名: " + name);
}
// 4. 可变参数与数组的区别（可变参数可接受0个或多个）
public void sum(int... nums) {
int total = 0;
for (int n : nums) total += n;
System.out.println("总和: " + total);
}
// 注意：不能同时存在以下两个方法（编译器无法区分）
// public void sum(int[] nums) { }
}
3.2 重载与类型提升
public class TypePromotionDemo {
public void test(int a) {
System.out.println("int: " + a);
}
public void test(long a) {
System.out.println("long: " + a);
}
public void test(double a) {
System.out.println("double: " + a);
}
public void demo() {
test(10); // 调用 test(int)
test(10L); // 调用 test(long)
test(10.0); // 调用 test(double)
test('A'); // char → int，调用 test(int)
test(10.0f); // float → double，调用 test(double)
}
}
