编程马·菜鸟教程

Appearance

9.3 方法的参数与返回值 ​

方法的参数 ​

方法的参数是指方法接收的输入数据，用于方法内部的计算和处理。参数可以是基本数据类型，也可以是引用数据类型。

参数的类型 ​

1. 基本数据类型参数 ​

基本数据类型参数包括：byte、short、int、long、float、double、char、boolean。

示例：

java
public static int add(int a, int b) {
    return a + b;
}

public static double divide(double numerator, double denominator) {
    return numerator / denominator;
}

public static boolean isEven(int number) {
    return number % 2 == 0;
}

2. 引用数据类型参数 ​

引用数据类型参数包括：类、接口、数组等。

示例：

java
public static void printArray(int[] array) {
    for (int element : array) {
        System.out.print(element + " ");
    }
    System.out.println();
}

public static String concatenate(String s1, String s2) {
    return s1 + s2;
}

public static void modifyList(List<Integer> list) {
    list.add(100);
}

参数的传递方式 ​

在 Java 中，方法参数的传递是值传递，即传递的是参数值的副本。

1. 基本数据类型参数的传递 ​

对于基本数据类型参数，传递的是参数值的副本，修改参数不会影响原始变量。

示例：

java
public class BasicTypeParameterExample {
    public static void main(String[] args) {
        int x = 5;
        System.out.println("Before: " + x); // 输出 5
        modify(x);
        System.out.println("After: " + x); // 输出 5，因为修改的是副本
    }
    
    public static void modify(int value) {
        value = 10;
        System.out.println("Inside modify: " + value); // 输出 10
    }
}

2. 引用数据类型参数的传递 ​

对于引用数据类型参数，传递的是对象的引用（内存地址），修改对象的内部状态会影响原始对象。

示例：

java
public class ReferenceTypeParameterExample {
    public static void main(String[] args) {
        int[] array = {1, 2, 3};
        System.out.println("Before: " + array[0]); // 输出 1
        modify(array);
        System.out.println("After: " + array[0]); // 输出 10，因为修改了对象的内部状态
    }
    
    public static void modify(int[] arr) {
        arr[0] = 10;
        System.out.println("Inside modify: " + arr[0]); // 输出 10
    }
}

可变参数 ​

可变参数是指方法可以接收任意数量的参数，使用 ... 表示。可变参数必须是方法的最后一个参数。

语法：

java
[修饰符] 返回类型 方法名(类型... 参数名) {
    // 方法体
}

示例：

java
public class VarargsExample {
    public static void main(String[] args) {
        // 调用可变参数方法
        int sum1 = add(1, 2, 3);
        int sum2 = add(1, 2, 3, 4, 5);
        int sum3 = add();
        
        System.out.println("Sum 1: " + sum1); // 输出 6
        System.out.println("Sum 2: " + sum2); // 输出 15
        System.out.println("Sum 3: " + sum3); // 输出 0
    }
    
    public static int add(int... numbers) {
        int sum = 0;
        for (int number : numbers) {
            sum += number;
        }
        return sum;
    }
}

方法的返回值 ​

方法的返回值是指方法执行后返回的结果，用于传递方法的执行结果给调用者。

返回值的类型 ​

返回值的类型可以是任何 Java 类型，包括基本数据类型、引用数据类型和 void（无返回值）。

1. 基本数据类型返回值 ​

示例：

java
public static int add(int a, int b) {
    return a + b;
}

public static double average(int[] array) {
    int sum = 0;
    for (int number : array) {
        sum += number;
    }
    return (double) sum / array.length;
}

public static boolean isPositive(int number) {
    return number > 0;
}

2. 引用数据类型返回值 ​

示例：

java
public static int[] createArray(int size) {
    int[] array = new int[size];
    for (int i = 0; i < size; i++) {
        array[i] = i + 1;
    }
    return array;
}

public static String getGreeting(String name) {
    return "Hello, " + name + "!";
}

public static List<Integer> getEvenNumbers(int[] array) {
    List<Integer> evenNumbers = new ArrayList<>();
    for (int number : array) {
        if (number % 2 == 0) {
            evenNumbers.add(number);
        }
    }
    return evenNumbers;
}

3. 无返回值 ​

如果方法不需要返回值，可以使用 void 作为返回类型。

示例：

java
public static void printMessage(String message) {
    System.out.println(message);
}

public static void sortArray(int[] array) {
    Arrays.sort(array);
}

public static void printArray(int[] array) {
    for (int element : array) {
        System.out.print(element + " ");
    }
    System.out.println();
}

多返回值的处理 ​

Java 方法只能返回一个值，但可以通过以下方式实现多返回值：

1. 使用数组 ​

java
public static int[] getMinMax(int[] array) {
    int min = array[0];
    int max = array[0];
    for (int number : array) {
        if (number < min) {
            min = number;
        }
        if (number > max) {
            max = number;
        }
    }
    return new int[]{min, max};
}

2. 使用对象 ​

java
public class MinMax {
    private int min;
    private int max;
    
    public MinMax(int min, int max) {
        this.min = min;
        this.max = max;
    }
    
    public int getMin() {
        return min;
    }
    
    public int getMax() {
        return max;
    }
}

public static MinMax getMinMax(int[] array) {
    int min = array[0];
    int max = array[0];
    for (int number : array) {
        if (number < min) {
            min = number;
        }
        if (number > max) {
            max = number;
        }
    }
    return new MinMax(min, max);
}

3. 使用集合 ​

java
public static List<Integer> getEvenAndOddNumbers(int[] array) {
    List<Integer> result = new ArrayList<>();
    List<Integer> evenNumbers = new ArrayList<>();
    List<Integer> oddNumbers = new ArrayList<>();
    
    for (int number : array) {
        if (number % 2 == 0) {
            evenNumbers.add(number);
        } else {
            oddNumbers.add(number);
        }
    }
    
    result.add(evenNumbers.size());
    result.addAll(evenNumbers);
    result.add(oddNumbers.size());
    result.addAll(oddNumbers);
    
    return result;
}

示例：方法的参数与返回值 ​

示例 1：基本数据类型参数和返回值 ​

java
public class BasicTypeExample {
    public static void main(String[] args) {
        int a = 5;
        int b = 3;
        
        int sum = add(a, b);
        int difference = subtract(a, b);
        int product = multiply(a, b);
        double quotient = divide(a, b);
        
        System.out.println("Sum: " + sum);
        System.out.println("Difference: " + difference);
        System.out.println("Product: " + product);
        System.out.println("Quotient: " + quotient);
    }
    
    public static int add(int a, int b) {
        return a + b;
    }
    
    public static int subtract(int a, int b) {
        return a - b;
    }
    
    public static int multiply(int a, int b) {
        return a * b;
    }
    
    public static double divide(int a, int b) {
        return (double) a / b;
    }
}

示例 2：引用数据类型参数和返回值 ​

java
public class ReferenceTypeExample {
    public static void main(String[] args) {
        int[] array = {5, 3, 9, 1, 7};
        
        System.out.println("Original array:");
        printArray(array);
        
        int[] sortedArray = sortArray(array);
        System.out.println("Sorted array:");
        printArray(sortedArray);
        
        int[] reversedArray = reverseArray(array);
        System.out.println("Reversed array:");
        printArray(reversedArray);
    }
    
    public static int[] sortArray(int[] array) {
        int[] sortedArray = array.clone();
        Arrays.sort(sortedArray);
        return sortedArray;
    }
    
    public static int[] reverseArray(int[] array) {
        int[] reversedArray = new int[array.length];
        for (int i = 0; i < array.length; i++) {
            reversedArray[i] = array[array.length - 1 - i];
        }
        return reversedArray;
    }
    
    public static void printArray(int[] array) {
        for (int element : array) {
            System.out.print(element + " ");
        }
        System.out.println();
    }
}

示例 3：可变参数 ​

java
public class VarargsExample {
    public static void main(String[] args) {
        // 调用可变参数方法
        System.out.println("Sum of 1, 2, 3: " + sum(1, 2, 3));
        System.out.println("Sum of 1, 2, 3, 4, 5: " + sum(1, 2, 3, 4, 5));
        System.out.println("Sum of no numbers: " + sum());
        
        // 传递数组给可变参数方法
        int[] numbers = {10, 20, 30};
        System.out.println("Sum of array: " + sum(numbers));
    }
    
    public static int sum(int... numbers) {
        int sum = 0;
        for (int number : numbers) {
            sum += number;
        }
        return sum;
    }
}

示例 4：多返回值处理 ​

java
public class MultipleReturnValuesExample {
    public static void main(String[] args) {
        int[] array = {5, 3, 9, 1, 7};
        
        // 使用数组返回多个值
        int[] minMaxArray = getMinMaxUsingArray(array);
        System.out.println("Min: " + minMaxArray[0] + ", Max: " + minMaxArray[1]);
        
        // 使用对象返回多个值
        MinMax minMaxObject = getMinMaxUsingObject(array);
        System.out.println("Min: " + minMaxObject.getMin() + ", Max: " + minMaxObject.getMax());
    }
    
    public static int[] getMinMaxUsingArray(int[] array) {
        int min = array[0];
        int max = array[0];
        for (int number : array) {
            if (number < min) {
                min = number;
            }
            if (number > max) {
                max = number;
            }
        }
        return new int[]{min, max};
    }
    
    public static MinMax getMinMaxUsingObject(int[] array) {
        int min = array[0];
        int max = array[0];
        for (int number : array) {
            if (number < min) {
                min = number;
            }
            if (number > max) {
                max = number;
            }
        }
        return new MinMax(min, max);
    }
}

class MinMax {
    private int min;
    private int max;
    
    public MinMax(int min, int max) {
        this.min = min;
        this.max = max;
    }
    
    public int getMin() {
        return min;
    }
    
    public int getMax() {
        return max;
    }
}

常见问题 ​

1. 参数类型不匹配 ​

症状：编译错误：error: incompatible types

解决方案：确保传递的参数类型与方法定义的参数类型一致

2. 参数数量不匹配 ​

症状：编译错误：error: method methodName in class ClassName cannot be applied to given types

解决方案：确保传递的参数数量与方法定义的参数数量一致

3. 返回值类型不匹配 ​

症状：编译错误：error: incompatible types

解决方案：确保方法的返回值类型与方法定义的返回值类型一致

4. 缺少 return 语句 ​

症状：编译错误：error: missing return statement

解决方案：确保有返回值的方法在所有执行路径上都有 return 语句

5. 可变参数的位置错误 ​

症状：编译错误：error: varargs parameter must be the last parameter

解决方案：确保可变参数是方法的最后一个参数

总结 ​

方法的参数与返回值是 Java 方法的重要组成部分。参数用于向方法传递数据，返回值用于从方法获取结果。

在使用方法的参数与返回值时，需要注意：

  • 方法参数的传递是值传递
  • 基本数据类型参数传递的是值的副本，修改参数不会影响原始变量
  • 引用数据类型参数传递的是对象的引用，修改对象的内部状态会影响原始对象
  • 可变参数可以接收任意数量的参数，必须是方法的最后一个参数
  • Java 方法只能返回一个值，但可以通过数组、对象或集合实现多返回值

通过合理使用方法的参数与返回值，可以使方法更加灵活和功能强大。

© 2026 编程马·菜鸟教程 版权所有

基于 VitePress 构建