Java函数参数-如何传递参数到函数以及不同类型的参数

Java 函数参数是指在函数调用时传递给函数的值。Java 函数参数允许我们将数据传递给函数，并将这些数据进行处理，然后返回一个值。本篇文章将介绍如何传递参数到函数以及不同类型的参数。

### 1. 如何传递参数到函数

Java 函数定义时可以指定参数列表，用于接收调用该函数时传递的参数。你可以在函数体中使用这些参数来完成函数功能的实现。传递参数的方式有两种：

- 值传递 (Call by value)：传递的是实参的值，函数拿到的只是值的一个拷贝；

- 引用传递 (Call by reference)：传递的是实参的引用，函数可以修改实参的值。

借助 Java 传递参数的实例代码来更深入地理解这两种参数的传递方式：

public class PassByValueDemo {

    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println("Before swap: a = " + a + ", b = " + b);
        swap(a, b);
        System.out.println("After swap: a = " + a + ", b = " + b);
    }

    public static void swap(int x, int y) {
        int temp = x;
        x = y;
        y = temp;
    }
}

在上面的程序中，swap 方法接受两个形参 x 和 y 作为传递的参数，并尝试交换它们的值。我们在主函数中声明两个变量 a 和 b，并向 swap 方法传递它们。运行程序，发现交换并没有生效，因为 Java 是采用值传递的方式进行参数传递的。

如果我们想要使用引用传递的方式来进行参数传递，我们应当借助 Java 的类类型实现。通过将参数封装在一个类实例中，我们可以传递引用来访问和修改所传递的参数：

public class PassByReferenceDemo {

    public static void main(String[] args) {
        MyInt a = new MyInt(10);
        MyInt b = new MyInt(20);
        System.out.println("Before swap: a = " + a.getValue() + ", b = " + b.getValue());
        swap(a, b);
        System.out.println("After swap: a = " + a.getValue() + ", b = " + b.getValue());
    }

    public static void swap(MyInt x, MyInt y) {
        int temp = x.getValue();
        x.setValue(y.getValue());
        y.setValue(temp);
    }
}

class MyInt {
    private int value;

    public MyInt(int value) {
        this.value = value;
    }

    public int getValue() {
        return value;
    }

    public void setValue(int value) {
        this.value = value;
    }
}

在上述程序中，我们定义了一个 MyInt 类型，它包含一个整数值并提供了访问和修改该值的方法。然后，我们使用 MyInt 类型的实例来传递参数。在 swap 方法内部，我们通过调用 MyInt 实例的 setValue 和 getValue 方法来实现参数的交换。

### 2. 不同类型的参数

Java 函数中使用各种类型的参数以接收各种信息，并根据需要处理它们。Java 支持以下几种类型的参数：

- 基本数据类型参数：比如 int、double、char、boolean 等；

- 引用数据类型参数：比如数组、类、接口、枚举等；

- 可变参数：JDK1.5 引入的新特性，用于接受不定数量的参数；

- 参数可变性：从 Java 5 开始，Java 引入了自动装箱和拆箱功能来支持参数的传递和接收。

接下来，我们将逐一介绍每种类型的参数。

#### 2.1 基本数据类型参数

我们在函数中使用基本数据类型参数时，实际上传递的是该数据类型的副本，因此在函数内部对传递的参数的操作也只是对复制的副本而不是原本执行的。如果我们修改了副本中的值，则不会影响原始数据。基本数据类型参数包括 int、double、boolean、float、byte、short 和 char。

下面是一个使用基本数据类型参数的函数：

public class BasicDataTypeParam {

    public static void modifyValue(int value) {
        System.out.println("Original value: " + value);
        value = value * 2;
        System.out.println("Double value: " + value);
    }

    public static void main(String[] args) {
        int number = 5;
        modifyValue(number);
        System.out.println("Original data: " + number);
    }
}

在上述程序中，modifyValue 方法接受一个整数类型的参数，并将其乘以 2。我们在 main 函数中声明一个整数变量 number 并将其初始化为 5，然后将该变量作为参数传递给 modifyValue 方法。在输出语句中，我们可以看到虽然 modifyValue 方法中修改了参数的值，但 main 函数中原始变量的值并未受到影响。

#### 2.2 引用数据类型参数

引用数据类型参数用于传递数组、类、接口、枚举等类型的数据。 Java 中的引用数据类型变量存储的是内存地址，而不是实际的值，因此在函数内部对传递的引用数据类型的操作将直接作用于该数据类型的副本。但由于复制的副本引用了相同的原始数据，因此对参数的修改会直接影响原始数据。

public class ReferenceDataTypeParam {

    public static void modifyArray(int[] data) {
        System.out.print("Original data: ");
        for (int i = 0; i < data.length; i++) {
            System.out.print(data[i] + " ");
        }
        System.out.println();
        for (int i = 0; i < data.length; i++) {
            data[i] = data[i] * 2;
        }
        System.out.print("Double data: ");
        for (int i = 0; i < data.length; i++) {
            System.out.print(data[i] + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        int[] array = {2, 4, 6, 8, 10};
        modifyArray(array);
        System.out.print("Original data: ");
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
        System.out.println();
    }
}

在上述程序中，我们定义了 modifyArray 方法，该方法接受一个整数类型的数组并将其中的每个元素乘以 2。我们在 main 函数中声明一个整数数组 array，并将其初始化为 {2, 4, 6, 8, 10}，然后将该变量作为参数传递给 modifyArray 方法。在输出语句中，我们可以看到虽然在 modifyArray 方法中修改了参数的值并存储到新的数组，但原始变量同时也被影响到了。

#### 2.3 可变参数

可变参数是 JDK1.5 引入的新特性，用于接受不定数量的参数。可变参数列表是指方法可以接受不定数量的参数，可以是任意类型的实例或基本类型数据。Java 可变参数的关键在于省略构造难点的数组初始化，这意味着我们只需要指定可变参数的类型，而不需要指定数组的长度。

public class VarargsExample {

    public static void main(String[] args) {
        System.out.println(sum(1, 2, 3, 4, 5));
    }

    private static int sum(int... nums) {
        int res = 0;
        for (int num : nums) {
            res += num;
        }
        return res;
    }
}

上面的程序中，我们