Java数组传递及可变参数操作实例详解
作者：下班后的爪哇菌
本文实例讲述了Java数组传递及可变参数操作。分享给大家供大家参考，具体如下：
方法可以操作传递和返回基本数据类型，但是方法中也可用来传递和返回数组。如果要向方法中传递一个数组，则方法的接收参数处必须是符合其类型的数组。而且数组属于引用数据类型，所以在把数组传递进方法之后，如果方法对数组本身做了任何修改，修改结果都是会保存下来的。
向方法中传递数组
在java中，所有对象都是通过引用进行操作的。而数组也是一种对象，当把数组作为参数传递给方法时，传递的实际上就是数组对象的引用。在方法中对数组的所有操作，都会映射到原数组中。而所谓的"引用"，就是java对象在堆内存的地址赋给了多个"栈内存"的变量。
public class Test {
public static void main(String[] args) {
int[] array = { 1, 3, 5 }; // 使用静态初始化定义数组
method(array); // 传递数组引用
for (int i = 0; i < array.length; i++) { // 循环输出
System.out.print(array[i] + "\t");
}
}
public static void method(int[] x) { // 接收整型数组引用
x[0] = 6; // 修改第一个元素的内容
}
}
执行结果：
6 3 5
我们来看一下其执行时的内存状态：
使用方法返回一个数组
既然方法可以接收一个数组，那么方法也就可以返回一个数组，则此时，只需要在返回值类型声明处明确的写出返回的数组类型即可。
public class Test {
public static void main(String[] args) {
int[] array = method(); // 通过方法实例化数组
print(array); // 向print()方法中传递数组
}
public static void print(int x[]) { // 接收数组
for (int i = 0; i < x.length; i++) { // 循环输出
System.out.print(x[i] + "");
}
}
public static int[] method() { // 此方法返回一个数组引用
int ss[] = { 1, 3, 5, 7, 9 }; // 定义一个数组
return ss; // 返回数组
}
}
执行结果：
1 3 5 7 9
可变参数（JDK 1.5）
JDK 1.5 开始，Java支持传递同类型的可变参数给一个方法。一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。
声明方式：
返回值类型 方法名称(类型…参数名称){ // 在方法声明中，在指定参数类型后加一个省略号(...)
// 方法体
}
可变参数方法的使用与方法参数部分使用数组是一致的，例如可以循环输出所有的参数值。
public static void print(String...names) { // 接收数组
for(String name : names) {
System.out.print(name + " ");
}
System.out.println();
}
调用的时候可以给出任意多个参数也可不给参数，例如：
public static void main(String[] args) {
String[] names = {"jerry", "tom", "rose"};
print(); // 不传递参数
print("jerry", "tom"); // 传递多个参数
print(names); // 传递数组
}
从以上代码可知，调用使用了可变参数的方法时：
1）可以不写参数，即传入空参；
2）可以直接在里边写入参数，参数间用逗号隔开；
3）可以传入一个数组；
可变参数的使用规则
1） 拥有可变参数的方法可以被重载，在调用方法的时候，如果能够和固定参数的方法匹配，也能够与可变长参数的方法匹配，则选择固定参数的方法。
public class Test {
public static void main(String[] args) {
print();
print("jerry");
print("jerry", "tom");
}
public static void print(String...names) { // 接收数组
System.out.print("可变参数方法： ");
for(String name : names) {
System.out.print(name + " ");
}
System.out.print("\n");
}
public static void print(String name) { // 接收一个String类型参数
System.out.println("固定参数方法： " + name);
}
}
执行结果如下：
可变参数方法： 固定参数方法： jerry 可变参数方法： jerry tom
2）如果要调用的方法可以和两个可变参数匹配，则出现错误。
public class Test {
public static void main(String[] args) {
print();
print("jerry"); // 编译错误
print("jerry", "tom"); // 编译错误
}
public static void print(String...names) {
System.out.println("------1------");
}
public static void print(String name, String...names) {
System.out.println("------2------ ");
}
}
main方法中的两个传参的调用都不能编译通过，因为编译器不知道该选哪个方法调用，如下所示：
3）一个方法只能有一个可变长参数，并且这个可变长参数必须是该方法的最后一个参数
public class Test {
public static void print(String name, String...names) {
System.out.println("------1------");
}
public static void print(int[] Ids, String...names) {
System.out.println("------2------ ");
}
}
以下的方法定义都是错误的：
4）可变参数可以兼容数组参数，但数组参数无法兼容可变参数。
public class Test {
public static void main(String[] args) {
}
public void print(String... names){
System.out.println("-----1-----");
}
public void print(String[] names){
System.out.println("-----2-----");
}
}
当试图使用数组作为参数去实现重载时，会报错，说明可变参数与数组冲突（两者应该是一方能兼容另一方）。
public class Test {
public static void main(String[] args) {
Test test = new Test();
test.print("jerry","tom");
}
public void print(String[] namse){
System.out.println("----------");
}
}
如果定义一个参数为数组的方法，像调用可变参数的方法一样调用它是会报错，说明可变参数并不是一个数组。
可变长参数的使用规范
1） 避免带有可变长参数的方法重载
例如上面使用规则的第一个例子，编译器虽然知道怎么调用，但人容易陷入调用的陷阱及误区。
2） 别让null值和空值威胁到变长方法
public class Test {
public static void main(String[] args) {
print("人事部");
print("jerry", null);
}
public static void print(String dept, Integer...Ids) {
}
public static void print(String name, String...names ){
}
}
以上main方法里的两个调用编译都不通过：
因为两个方法都匹配，编译器不知道选哪个，于是报错了，这里同时还有个非常不好的编码习惯，即调用者隐藏了实参类型，这是非常危险的，不仅仅调用者需要“猜测”该调用哪个方法，而且被调用者也可能产生内部逻辑混乱的情况。对于本例来说应该做如下修改：
public static void main(String[] args) {
String[] names = null;
print("jerry", names);
}
3）重写（覆写）可变参数方法也要循规蹈矩
public class Test {
public static void main(String[] args) {
// 向上转型
Base base = new Sub();
base.print("hello");
// 不转型
Sub sub = new Sub();
sub.print("hello");
}
}
//基类
class Base {
void print(String... args) {
System.out.println("Base......test");
}
}
//子类，覆写父类方法
class Sub extends Base {
@Override
void print(String[] args) {
System.out.println("Sub......test");
}
}
以上main方法中第二个调用编译不通过：
第一个能编译通过，这是为什么呢？事实上，base对象把子类对象sub做了向上转型，形参列表是由父类决定的，当然能通过。再看看子类直接调用的情况，这时编译器看到子类覆写了父类的print方法，因此肯定使用子类重新定义的print方法，尽管参数列表不匹配也不会跑到父类再去匹配下，因为找到了就不再找了，因此有了类型不匹配的错误。
这是个特例，重写的方法参数列表与父类不相同，这违背了重写的定义，并且会引发莫名其妙的错误。在这里，我们再复习下重写必须满足的条件：
1）重写方法不能缩小访问权限；
2）参数列表必须与被重写方法相同（包括显示形式）；
3）返回类型必须与被重写方法的相同或是其子类；
4）重写方法不能抛出新的异常，或者超过了父类范围的异常，但是可以抛出更少、更有限的异常，或者不抛出异常。
最后，我们看下面一个有陷阱的例子：
public class Test {
public static void main(String[] args) {
print("");
print("jerry");
print("jerry", "tom");
}
public static void print(String name, String... names) {
for (int i = 0; i < names.length; i++) {
System.out.println(names[i]);
}
}
}
以上代码是能够正常编译执行的，它的执行结果如下：
tom
更多java相关内容感兴趣的读者可查看本站专题：《Java面向对象程序设计入门与进阶教程》、《Java数据结构与算法教程》、《Java操作DOM节点技巧总结》、《Java文件与目录操作技巧汇总》和《Java缓存操作技巧汇总》
希望本文所述对大家java程序设计有所帮助。