一、什么是可变参数函数
 
C语言允许定义参数数量可变的函数，这称为可变参数函数（variadic function）。这种函数需要固定数量的强制参数，后面是数量可变的可选参数。
 
其中，强制参数必须至少一个，可选参数数量可变，类型可变，可选参数的数量由强制参数的值决定，或由用来定义可选参数列表的特殊值决定。
 
其实我们早就接触过可变参数函数了，C 语言中最常用的可变参数函数例子是 printf（）和 scanf（）。这两个函数都有一个强制参数，即格式化字符串。格式化字符串中的转换修饰符决定了可选参数的数量和类型。（是吧，printf中可以有自定义个%d，没毛病）
 
可变参数函数的参数列表的格式是，强制性参数在前，后面跟着一个逗号和省略号（…），这个省略号代表可选参数。比如：int fun(int, …) (我随便举的例子啊)
 .
 .
 
二、可变参数函数的实现
 
1、问题引入
 
我们先来思考这样一个问题，作为本节的引入：
 如果我们要预先写一个可变参数的累加求和函数，其强制参数类型为int，用它来表示我们一共要传入多少个可变参数。于是我们大概可以有这么一个框架：
 
double getSum(int NumofPara, ...)
{
	int i = 0;
	double sum = 0.0;
	
	for( i = 0; i < NumofPara; i++ )
	{
		sum += ??		
	}
}
 
发现什么问题没有？
 
由于已经知道要传入多少个可变参数，所以求和思路就是，for循环遍历NumofPara次，每次都把sum加上一个可变参数。
 
思路很清晰，没毛病。但是，问题来了。由于是可变参数，我们无法提前得知可变参量的名字，也就没法访问这些可变参数。（你参数列表里都是一串省略号了，你怎么可能提前知道变量名，所以自然而然也无法表示、无法访问这些变量了）
 
2、实现思路
 
为了解决上述问题，C语言规定：
 
当编写可变参数函数时，必须用 va_list 类型定义参数指针，以获取可选参数。可变参数函数要获取可选参数时，必须通过一个类型为 va_list 的对象来进行访问，它包含了参数信息。
 
这种类型的对象也称为参数指针（argument pointer），它包含了栈中至少一个参数的位置。可以使用这个参数指针从一个可选参数移动到下一个可选参数，由此，函数就可以获取所有的可选参数。va_list 类型被定义在头文件 stdarg.h 中。
 
这么说可能太过官方，太抽象了。我们来举个例子。
 
假设我们有一个可变参数函数getSum(int NumofPara, …)，然后现在我们代入具体值，比如getSum(3, 7, 8, 9)，通过上面的介绍我们知道，第一个3是强制参数，表明后面跟了3个可变参量，而后面的7、8、9则为具体的可变参量。
 
根据C语言的要求，我们需要在getSum(int NumofPara, …)函数中定义一个va_list类型的指针。
 
然后它是怎么实现“访问、获取可选参数”的呢？
 
 C语言里是这样实现的：通过某种机制（等会儿会讲）让强制参数和可选参数在内存中以连续的方式存放（强制参数在前），同时让va_list指针指向最后一个强制参数，即第一个可选参数前的强制参数。然后，通过另一种机制，每次访问va_list所指的参量之后，指针自动向后移位。进而当下一次再访问va_list的时候，访问的就是下一位的值。这样就可以访问各个可变参数了。大概就是这样了，讲得太接地气了。
 
3、具体实现函数
 
那么，C语言又是怎么实现上面提到的这些机制的呢？
 
由此引入两个函数。
 
void va_start(va_list argptr, lastparam);
 是va_list指针的初始化函数，用来初始化指针，也就是实现让其“先指向最后一个强制参数”的功能。
 
于是自然而然的，该函数的第一个参数是一个va_list 类型的指针，第二个参数是可变参数函数中最后一个强制参数，即第一个可选参数前的强制参数。
 
va_start函数中，va_list进行初始化，指针指向末尾的强制参数。va_start结束后，初始化完成，指针自动移位到下一个参数，即第一个可变参数。（虽然感觉有点奇怪）
 
那么怎么访问va_list指针当前指向的可变参数呢？引出第二个函数：
 
type va_arg(va_list argptr, type);
 其第一个参数是已经初始化完成的va_list指针，第二个参数则为可变参数的类型，返回的参数就是当前va_list指针所指的可变参数，所以类型也跟传入的可变参数类型相同。
 
每一次通过va_arg函数访问完一次参数后，va_list指针会自动移位到下一位。
 
C语言还规定，当不再需要使用参数指针时，必须调用宏 va_end来终结该指针，其实说白了就是释放内存。（如果想使用宏 va_start 或者宏 va_copy 来重新初始化一个之前用过的参数指针，也必须先调用宏 va_end）
 
4、具体实现示例
 
好了，说了这么多，我们通过完善之前写了一半的getSum函数来具体了解一下，可能就会豁然开朗明明白白了：
 
double getSum(int NumofPara, ...)
{
	int i = 0;							//用于for循环 
	double sum = 0.0;					//用于求和 

	va_list pointer;					//新建一个va_list类型的指针 

	va_start(pointer, NumofPara);		//初始化指针，指针指向确定 
	
	for( i = 0; i < NumofPara; i++ )
	{
		sum += va_arg(pointer, double);	//通过va_arg函数来访问可变参数，返回类型为double 
	}									//同时，每次va_arg函数结束后，va_list指针指向下一位 
	
	va_end(pointer);					//终结指针，释放内存 
	
	return sum;

	//P.S. 有个问题要注意一下，在main函数里调用的时候，应该写成getSum(3, 7.0, 8.0, 9.0)，否则得到的可能是0。
}
 
接下来简单补充一下上面提到的所谓“机制”：
 
 
 
它的实现原理利用了内存的压栈技术，将参数压入（push）栈内，使用时，再逐个从栈里pop出来
 需要注意的是，压栈的顺序是从最右边参数开始的，再向左逐个压入，根据栈的原理，在取参数时，就从第一个可变参数开始了。
 在进程中,堆栈地址是从高到低分配的.当执行一个函数的时候,将参数列表入栈,压入堆栈的高地址部分,然后入栈函数的返回地址,接着入栈函数的执行代码,这个入栈过程,堆栈地址不断递减。
 （所以取的时候就是从低到高，也就是上面草图中从左到右从3到7到8到9）
 
 
三、不小心写多了一个标题
 
上面说得比较粗糙，可能有一些地方说错了。里面具体原理我也还没去深究。以后吧。
 
参考资料：
 C语言可变参数函数
 【干货】C语言可变参数
 C语言可变参数列表知识总结
 C语言中可变参数的使用方法
 基于本文知识点，下一次再来追补一些关于vsprintf函数的知识点。

C语言可变参数详解
 
什么是可变参数函数
 
在C语言编程中有时会遇到一些参数可变的函数，例如printf()、scanf()，其函数原型为：
 
int printf(const char* format,…)
int scanf(const char *format,…)
 
就拿 printf 来说吧，它除了有一个参数 format 固定以外，后面的参数其个数和类型都是可变的，用三个点“…”作为参数占位符。
 
参数列表的构成
 
任何一个可变参数的函数都可以分为两部分：固定参数和可选参数。至少要有一个固定参数，其声明与普通函数参数声明相同；可选参数由于数目不定(0个或以上)，声明时用"…"表示。固定参数和可选参数共同构成可变参数函数的参数列表。
 
实现原理
 
C语言中使用 va_list 系列变参宏实现变参函数，此处va意为variable-argument(可变参数)。
 
x86平台VC6.0编译器中，stdarg.h头文件内变参宏定义如下：
 
typedef char * va_list;

// 把 n 圆整到 sizeof(int) 的倍数
#define _INTSIZEOF(n)       ( (sizeof(n)+sizeof(int)-1) & ~(sizeof(int)-1) )

// 初始化 ap 指针，使其指向第一个可变参数。v 是变参列表的前一个参数
#define va_start(ap,v)      ( ap = (va_list)&v + _INTSIZEOF(v) )

// 该宏返回当前变参值,并使 ap 指向列表中的下个变参
#define va_arg(ap, type)    ( *(type *)((ap += _INTSIZEOF(type)) - _INTSIZEOF(type)) )

// /将指针 ap 置为无效，结束变参的获取
#define va_end(ap)             ( ap = (va_list)0 )
 
_INTSIZEOF(n)
 
_INTSIZEOF宏考虑到某些系统需要内存地址对齐。从宏名看应按照sizeof(int)即栈粒度对齐，参数在内存中的地址均为sizeof(int)=4的倍数。
 
例如，若1≤sizeof(n)≤4，则_INTSIZEOF(n)＝4；若5≤sizeof(n)≤8，则_INTSIZEOF(n)=8。
 
va_start(ap,v)
 
va_start宏首先根据(va_list)&v得到参数 v 在栈中的内存地址，加上_INTSIZEOF(v)即v所占内存大小后，使 ap 指向 v 的下一个参数。在使用的时候，一般用这个宏初始化 ap 指针，v 是变参列表的前一个参数，即最后一个固定参数，初始化的结果是 ap 指向第一个变参。
 
va_arg(ap, type)
 
这个宏取得 type 类型的可变参数值。首先ap += _INTSIZEOF(type)，即 ap 跳过当前可变参数而指向下个变参的地址；然后ap-_INTSIZEOF(type)得到当前变参的内存地址，类型转换后解引用，最后返回当前变参值。
 
va_end(ap)
 
va_end 宏使 ap 不再指向有效的内存地址。该宏的某些实现定义为((void*)0)，编译时不会为其产生代码，调用与否并无区别。但某些实现中 va_end 宏用于在函数返回前完成一些必要的清理工作：如 va_start 宏可能以某种方式修改栈，导致返回操作无法完成，va_end 宏可将有关修改复原；又如 va_start 宏可能为参数列表动态分配内存以便于遍历，va_end 宏可释放此内存。因此，从使用 va_start 宏的函数中退出之前，必须调用一次 va_end 宏。
 
代码示例
 
变参宏无法智能识别可变参数的数目和类型，因此实现变参函数时需自行判断可变参数的数目和类型。所以我们就要想一些办法，比如
 
显式提供变参数目或设定遍历结束条件
显式提供变参类型枚举值，或在固定参数中包含足够的类型信息(如printf函数通过分析format字符串即可确定各变参类型)
主调函数和被调函数可约定变参的数目和类型
…
 
例1：函数通过固定参数指定可变参数个数，打印所有变参值。
 
#include <stdarg.h>
#include <stdio.h>

void parse_valist_by_num(int arg_cnt, ...);

int main(void)
{
    parse_valist_by_num(4,1,2,3,4);
    parse_valist_by_num(4,1,2,3); 
    parse_valist_by_num(4,1,2,3,4,5); //多余的变参被忽略
}


//第一个参数定义可变参数的个数
void parse_valist_by_num(int arg_cnt, ...)
{
    
    va_list p_args;
    va_start(p_args, arg_cnt);
    
    int idx;
    int val;
    
    for(idx = 1; idx <= arg_cnt; ++idx){
        val = va_arg(p_args, int);
        printf("第 %d 个参数: %d\n", idx, val);
    }
    printf("---------------\n");
    va_end(p_args);
}
 
运行结果如下：
 
 
注意第2个结果，第4个参数是一个魔数，这是因为打印出了栈中参数3上方的参数值。
 
例2：函数定义一个结束标记(-1)，调用时通过最后一个参数传递该标记，打印标记前所有变参值。
 
#include <stdarg.h>
#include <stdio.h>

void parse_valist_by_flag(int num_1, ...);

int main(void)
{
    parse_valist_by_flag(1,-1);
    parse_valist_by_flag(1,2,3,5,-1);
    parse_valist_by_flag(-1);
    
}

//函数定义一个结束标记(-1)，调用时通过最后一个参数传递该标记，以结束变参的遍历打印。
//最后一个参数作为变参结束符(-1)，用于循环获取变参内容
void parse_valist_by_flag(int num_1, ...)
{
    va_list p_args;
    va_start(p_args, num_1);
    int idx = 0;
    int val = num_1;
    while(val != -1){
        ++idx;
        printf("第 %d 个参数: %d\n", idx, val);
        val = va_arg(p_args, int); //得到下个变参值
    }
    va_end(p_args);
    printf("---------------\n");
}
 
运行结果是：
 
 
需要注意
 
va_arg(ap, type)宏中的 type 不可指定为以下类型：
 
char
short
float
 
在C语言中，调用不带原型声明或声明为变参的函数时，主调函数会在传递未显式声明的参数前对其执行缺省参数提升(default argument promotions)，将提升后的参数值传递给被调函数。
 
​ 提升操作如下：
 
float 类型的参数提升为 double 类型
char、short 和相应的 signed、unsigned 类型参数提升为 int 类型
若 int 类型不能容纳原值，则提升为 unsigned int 类型
 
最后来一张图，帮助大家理解前文讲的宏。
 
 
【完】
 
参考资料
 
https://www.cnblogs.com/clover-toeic/p/3736748.html

在C++11之前，类模板和函数模板只能含有固定数量的模板参数。C++11增强了模板功能，允许模板定义中包含0到任意个模板参数，这就是可变参数模板。可变参数模板的加入使得C++11的功能变得更加强大，而由此也带来了许多神奇的用法。
 
本文实例源码github地址：https://github.com/yngzMiao/yngzmiao-blogs/tree/master/2020Q2/20200401。
 

 
可变参数模板
 
可变参数模板和普通模板的语义是一样的，只是写法上稍有区别，声明可变参数模板时需要在typename或class后面带上省略号...：
 
template<typename... Types>
 
其中，...可接纳的模板参数个数是0个及以上的任意数量，需要注意包括0个。
 
若不希望产生模板参数个数为0的变长参数模板，则可以采用以下的定义：
 
template<typename Head, typename... Tail>
 
本质上，...可接纳的模板参数个数仍然是0个及以上的任意数量，但由于多了一个Head类型，由此该模板可以接纳1个及其以上的模板参数。
 

 
函数模板的使用
 
在函数模板中，可变参数模板最常见的使用场景是以递归的方法取出可用参数：
 
void print() {}

template<typename T, typename... Types>
void print(const T& firstArg, const Types&... args) {
	std::cout << firstArg << " " << sizeof...(args) << std::endl;
	print(args...);
}
 
通过设置...，可以向print函数传递任意个数的参数，并且各个参数的类型也是任意。也就是说，可以允许模板参数接受任意多个不同类型的不同参数。这就是不定参数的模板，格外需要关注的是，...三次出现的位置。
 
如果如下调用print函数：
 
print(2, "hello", 1);
 
如此调用会递归将3个参数全部打印。细心的话会发现定义了一个空的print函数，这是因为当使用可变参数的模板，需要定义一个处理最后情况的函数，如果不写，会编译错误。这种递归的方式，是不是觉得很惊艳！
 
在不定参数的模板函数中，还可以通过如下方式获得args的参数个数：
 
sizeof...(args)
 
假设，在上面代码的基础上再加上一个模板函数如下，那么运行的结果是什么呢？
 
#include <iostream>

void print() {}

template<typename T, typename... Types>
void print(const T& firstArg, const Types&... args) {
	std::cout << firstArg << " " << sizeof...(args) << std::endl;
	print(args...);
}

template <typename... Types>
void print(const Types&... args) {
  std::cout << "print(...)" << std::endl;
}

int main(int argc, char *argv[]) {
	print(2, "hello", 1);

	return 0;
}
 
现在有一个模板函数接纳一个参数加上可变参数，还有一个模板函数直接接纳可变参数，如果调用print(2, “hello”, 1)，会发现这两个模板函数的参数格式都符合。是否会出现冲突、不冲突的话会执行哪一个呢？
 
运行代码后的结果为：
 
yngzmiao@yngzmiao-virtual-machine:~/test/$ ./main 
2 2
hello 1
1 0
 
从结果上可以看出，程序最终选择了一个参数加上不定参数的模板函数。也就是说，当较泛化和较特化的模板函数同时存在的时候，最终程序会执行较特化的那一个。
 
再比如一个例子，std::max函数只可以返回两个数的较大者，如果多个数，就可以通过不定参数的模板来实现：
 
#include <iostream>

template <typename T>
T my_max(T value) {
  return value;
}

template <typename T, typename... Types>
T my_max(T value, Types... args) {
  return std::max(value, my_max(args...));
}

int main(int argc, char *argv[]) {
  std::cout << my_max(1, 5, 8, 4, 6) << std::endl;

	return 0;
}
 

 
类模板的使用
 
除了函数模板的使用外，类模板也可以使用不定参数的模板参数，最典型的就是tuple类了。其大致代码如下：
 
#include <iostream>

template<typename... Values> class tuple;
template<> class tuple<> {};

template<typename Head, typename... Tail>
class tuple<Head, Tail...>
  : private tuple<Tail...>
{
  typedef tuple<Tail...> inherited;
  public:
    tuple() {}
    tuple(Head v, Tail... vtail) : m_head(v), inherited(vtail...) {}
    Head& head() {return m_head;}
    inherited& tail() {return *this;}
  protected:
    Head m_head;
};

int main(int argc, char *argv[]) {
	tuple<int, float, std::string> t(1, 2.3, "hello");
	std::cout << t.head() << " " << t.tail().head() << " " << t.tail().tail().head() << std::endl;

	return 0;
}
 
根据代码可以知道，tuple类继承除首之外的其他参数的子tuple类，以此类推，最终继承空参数的tuple类。继承关系可以表述为：
 
tuple<>
      ↑
tuple<std::string>
  string "hello"
      ↑
tuple<float, std::string>
  float 2.3
      ↑
tuple<int, float, std::string>
  int 1
 
接下来考虑在内存中的分布，内存中先存储父类的变量成员，再保存子类的变量成员，也就是说，对象t按照内存分布来说；
 
┌─────────┐<---- 对象指针
|  hello  |
|─────────|
|  2.3    |
|─────────|
|  1      |
└─────────┘
 
这时候就可以知道下一句代码的含义了：
 
inherited& tail() {return *this;}
 
tail()函数返回的是父类对象，父类对象和子类对象的内存起始地址其实是一样的，因此返回*this，再强行转化为inherited类型。
 
当然，上面采用的是递归继承的方式，除此之外，还可以采用递归复合的方式：
 
template<typename... Values> class tup;
template<> class tup<> {};

template<typename Head, typename... Tail>
class tup<Head, Tail...>
{
  typedef tup<Tail...> composited;
  public:
    tup() {}
    tup(Head v, Tail... vtail) : m_head(v), m_tail(vtail...) {}
    Head& head() {return m_head;}
    composited& tail() {return m_tail;}
  protected:
    Head m_head;
    composited m_tail;
};
 
两种方式在使用的过程中没有什么区别，但C++11中采用的是第一种方式(递归继承)。
 
在上面的例子中，取出tuple中的元素是一个比较复杂的操作，需要不断地取tail，最终取head才能获得。标准库的std::tuple，对此进行简化，还提供了一些其他的函数来进行对tuple的访问。例如：
 
#include <iostream>
#include <tuple>

int main(int argc, char *argv[]) {
  std::tuple<int, float, std::string> t2(1, 2.3, "hello");
  std::get<0>(t2) = 4;                      // 修改tuple内的元素
  std::cout << std::get<0>(t2) << " " << std::get<1>(t2) << " " << std::get<2>(t2) << std::endl;    // 获取tuple内的元素

  auto t3 = std::make_tuple(2, 3.4, "World");         // make方法生成tuple对象
  
  std::cout << std::tuple_size<decltype(t3)>::value << std::endl;    // 获取tuple对象元素的个数
  std::tuple_element<1, decltype(t3)>::type f = 1.2;          // 获取tuple对象某元素的类型

	return 0;
}
 

 
相关阅读
 
C++标准库元组（tuple）源码浅析
 

  

方法可以操作传递和返回基本数据类型，但是方法中也可用来传递和返回数组。如果要向方法中传递一个数组，则方法的接收参数处必须是符合其类型的数组。而且数组属于引用数据类型，所以在把数组传递进方法之后，如果方法对数组本身做了任何修改，修改结果都是会保存下来的。
 
 
 
向方法中传递数组
 
在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