变长参数的坑

2014-12-19

VarArgs简述

只需要明确一点即可,java方法的变长参数只是语法糖,其本质上还是将变长的实际参数 varargs 包装为一个数组。

所以

Object[] objs

Object... objs

被看作是相同的签名,在源码级别是不能同时存在的,因此,无法编译通过

VarArgs包装

包装方式(注意,下面的代码不是实际的实现,而是一个比喻说明):

  1. 如果实参是唯一且匹配形参varargs要求的数组(就是实参独占形参varargs),那么可以认为你已经替编译器干了这个活,所以可以看作不包装,直接使用这个数组
        public void invoke(String...varargs){}

        invoke(new String[]{"a", "b", "c"});
        那么大致的调用过程如下:
        public void invoke(String...varargs){
            innerVarArgs = varargs;
        }
  1. 如果实参是多个单独的变量(就是多个实参分享varargs),那么会将这多个参数包装成一个相应的类型数组
        public void invoke(String...varargs){}

        invoke("a", "b", "c");

        那么大致的调用过程如下:
        public void invoke(String...varargs){
            innerVarArgs = new String[varargs.length];
            for(int i = 0, size = varargs; i < size; i++){
                innerVarArgs[i] = varargs[i];
            }
        }

那么问题来了

问题一:当变长参数是Object… objs的情况

要知道,数组也是一个对象,所以会产生下面的情况:

        public static void test1(Object... varargs) {
            System.out.println(varargs.length);
        }

        [1] test1(new String[]{"a", "b", "c"});   //3
        [2] test1(1, new String[]{"a", "b", "c"});//2

        [3] test1(new Integer[]{2, 3, 4});        //3
        [4] test1(1, new Integer[]{2, 3, 4});     //2
        [5] test1(1, new Integer[]{2, 3, 4}, new Integer[]{2, 3, 4});//3

        [6] test1(2, 3, 4);              //3
        [7] test1(new int[]{2, 3, 4});   //1
        [8] test1(1, new int[]{2, 3, 4});//2

结果分析:

  1. [1]test1的实参是唯一的数组new String[]{“a”, “b”, “c”},因此直接使用
  2. [2]test1的实参有两项,而且这两项都符合varargs的要求,实参数组无法独占形参varargs,编译器看到的是test1(1, ArrayObject), 因此包装侯结果为Object[]{1, ArrayObject} [注意,ArrayObject只是为了在本文中说明这个对像是一个数组,实际并不存在这种类型]
  3. 其他同理
问题二:int[] 与 Integer[]

注意问题一里面的[3]和[7],两者的结果是不一样的,原因:

int[]是没有办法直接转型成Object[]的,基本类型与Object也是无法匹配上的,因此,退而求其次,int[]被当作一个单纯的数组对象ArrayObject,包装结果为Object[]{ArrayObject},因此数组长度为1。

Integer[]本身就可以看作是Object[],因此参照包装方式一,可以直接使用这个数组,因此数组长度不变。

VarArgs在反射中的注意点

首先需要明确的一点是,反射是在运行时才能产生作用的,因此,下面两个方法的效果是一样的:

        public void fn(String[] args) {}

        public void fn(String... args) {}

在运行时看来,此方法的签名就是:

    public void fn([java.lang.String args) // public void fn(String[] args)

注意,此时方法形参只有一个,就是那个 String[] args

一个示例:

    public class Reflect {

        public static void main(String[] args) throws Exception {

            String[] mArgs = new String[]{"a", "b", "c"};

            Method mFn1 = Reflect.class.getMethod("fn1", mArgs.getClass());
            /*[调用1]*/mFn1.invoke(null, new Object[]{mArgs}); // 3
            /*[调用2]*/mFn1.invoke(null, (Object) mArgs);      // 3
            /*[调用3]*/mFn1.invoke(null, mArgs);               // error
        }

        public static void fn1(String... args) {
            System.out.println("fn1:" + args.length);
        }
    }

现在看一下Method的invoke方法:

    public Object invoke(Object obj, Object... args)

转化为对应的方法调用为:

fn1(args) //fn1签名 public void fn([java.lang.String args)
  1. [调用1]mFn1.invoke(null, new Object[]{mArgs});

     相当与调用fn1(mArgs),即fn1(new String[]{"a", "b", "c"})
    
  2. [调用2]mFn1.invoke(null, (Object) mArgs);

     mArgs被包装 -> mFn1.invoke(null, new Object[]{mArgs}) 转化为[调用1]
    
  3. [调用3]mFn1.invoke(null, mArgs);

    不包装,直接使用。 即调用fn1(“a”, “b”, “c”),但是fn1只接受一个参数,即String[] args,所以会报”wrong number of arguments”错误,即参数数量不对


文档信息 by XiaoPingYuan

版权声明:自由转载-非商用-非衍生-保持署名。发表日期:2014-12-19 by XiaoPingYuan(https://xesam.github.io/)