避免带有变长参数的方法重载，别让null值和空值威胁到变长方法，覆写变长方法也循规蹈矩

    变长参数也是要遵循一定规则的，比如变长参数必须是方法中的最后一个参数；一个方法不能定义多个变长参数等，这些基本规则需要牢记，但是即使记住了这些规则，仍然有可能出现错误，我们来看如下代码：

<span style="font-size:18px;">    public class Client {
//简单折扣计算
public void calPrice(int price,int discount){
float knockdownPrice =price * discount / 100.0F;
System.out.println("简单折扣后的价格是："+formateCurrency(knockdownPrice));
}
//复杂多折扣计算
public void calPrice(int price,int... discounts){
float knockdownPrice = price;
for(int discount:discounts){
knockdownPriceknockdownPrice = knockdownPrice * discount / 100;
}
System.out.println("复杂折扣后的价格是：" +formateCurrency(knockdownPrice));
}
//格式化成本的货币形式
private String formateCurrency(float price){
return NumberFormat.getCurrencyInstance().format(price/100);
}

public static void main(String[] args) {
Client client = new Client();
//499元的货物，打75折
client.calPrice(49900, 75);
}
} </span>

我们知道Java编译器是很聪明的，它在编译时会根据方法签名（Method Signature）来确定调用哪个方法，比如calPrice（499900,75,95）这个调用，很明显75和95会被转成一个包含两个元素的数组，并传递到calPrice（int price,in.. discounts）中，因为只有这一个方法签名符合该实参类型，这很容易理解。但是我们现在面对的是calPrice（49900,75）调用，这个“75”既可以被编译成int类型的“75”，也可以被编译成int数组“{75}”，即只包含一个元素的数组。那到底该调用哪一个方法呢？

我们先运行一下看看结果，运行结果是：

简单折扣后的价格是：￥374.25。

看来是调用了第一个方法，为什么会调用第一个方法，而不是第二个变长参数方法呢？因为Java在编译时，首先会根据实参的数量和类型（这里是2个实参，都为int类型，注意没有转成int数组）来进行处理，也就是查找到calPrice(int price,int discount)方法，而且确认它是否符合方法签名条件。现在的问题是编译器为什么会首先根据2个int类型的实参而不是1个int类型、1个int数组类型的实参来查找方法呢？这是个好问题，也非常好回答：因为int是一个原生数据类型，而数组本身是一个对象，编译器想要“偷懒”，于是它会从最简单的开始“猜想”，只要符合编译条件的即可通过，于是就出现了此问题。

问题是阐述清楚了，为了让我们的程序能被“人类”看懂，还是慎重考虑变长参数的方法重载吧，否则让人伤脑筋不说，说不定哪天就陷入这类小陷阱里了。

上面例子是变长参数的范围覆盖了非变长参数的范围，这次我们从两个都是变长参数的方法说起，代码如下：

<span style="font-size:18px;"> public class Client {
public void methodA(String str,Integer... is){
}

public void methodA(String str,String... strs){
}

public static void main(String[] args) {
Client client = new Client();
client.methodA("China", 0);
client.methodA("China", "People");
client.methodA("China");
client.methodA("China",null);
}
} </span>

两个methodA都进行了重载，现在的问题是：上面的代码编译通不过，问题出在什么地方？看似很简单哦。

有两处编译通不过：client.methodA（"China"）和client.methodA（"China",null），估计你已经猜到了，两处的提示是相同的：方法模糊不清，编译器不知道调用哪一个方法，但这两处代码反映的代码味道可是不同的。

对于methodA（"China"）方法，根据实参“China”（String类型），两个方法都符合形参格式，编译器不知道该调用哪个方法，于是报错。我们来思考这个问题：Client类是一个复杂的商业逻辑，提供了两个重载方法，从其他模块调用（系统内本地调用或系统外远程调用）时，调用者根据变长参数的规范调用，
传入变长参数的实参数量可以是N个（N>=0），那当然可以写成client.methodA（"china"）方法啊！完全符合规范，但是这却让编译器和调用者都很郁闷，程序符合规则却不能运行，如此问题，谁之责任呢？是Client类的设计者，他违反了KISS原则（Keep It Simple, Stupid，即懒人原则），按照此规则设计的方法应该很容易调用，可是现在在遵循规范的情况下，程序竟然出错了，这对设计者和开发者而言都是应该严禁出现的。

对于client.methodA（"china",null）方法，直接量null是没有类型的，虽然两个methodA方法都符合调用请求，但不知道调用哪一个，于是报错了。我们来体会一下它的坏味道：除了不符合上面的懒人原则外，这里还有一个非常不好的编码习惯，即调用者隐藏了实参类型，这是非常危险的，不仅仅调用者需要“猜测”该调用哪个方法，而且被调用者也可能产生内部逻辑混乱的情况。对于本例来说应该做如下修改：
<span style="font-size:18px;"> public static void main(String[] args) {
Client client = new Client();
String[] strs = null;
client.methodA("China",strs);
} </span>

也就是说让编译器知道这个null值是String类型的，编译即可顺利通过，也就减少了错误的发生。

覆写变长方法也循规蹈矩

<span style="font-size:18px;"> public class Client {
public static void main(String[] args) {
//向上转型
Base base = new Sub();
base.fun(100, 50);
//不转型
Sub sub = new Sub();
sub.fun(100, 50);
}
}
//基类
class Base{
void fun(int price,int... discounts){
System.out.println("Base......fun");
}
}

//子类，覆写父类方法
class Sub extends Base{
@Override
void fun(int price,int[] discounts){
System.out.println("Sub......fun");
}
} </span>
请问：该程序有问题吗？—编译通不过。那问题出在什么地方呢？

@Override注解吗？非也，覆写是正确的，因为父类的calPrice编译成字节码后的形参是一个int类型的形参加上一个int数组类型的形参，子类的参数列表也与此相同，那覆写是理所当然的了，所以加上@Override注解没有问题，只是Eclipse会提示这不是一种很好的编码风格。

难道是“sub.fun（100, 50）”这条语句？正解，确实是这条语句报错，提示找不到fun（int,int）方法。这太奇怪了：子类继承了父类的所有属性和方法，甭管是私有的还是公开的访问权限，同样的参数、同样的方法名，通过父类调用没有任何问题，通过子类调用却编译通不过，为啥？难道是没继承下来？或者子类缩小了父类方法的前置条件？那如果是这样，就不应该覆写，@Override就应该报错，真是奇妙的事情！

事实上，base对象是把子类对象Sub做了向上转型，形参列表是由父类决定的，由于是变长参数，在编译时，“base.fun(100, 50)”中的“50”这个实参会被编译器“猜测”而编译成“{50}”数组，再由子类Sub执行。我们再来看看直接调用子类的情况，这时编译器并不会把“50”做类型转换，因为数组本身也是一个对象，编译器还没有聪明到要在两个没有继承关系的类之间做转换，要知道Java是要求严格的类型匹配的，类型不匹配编译器自然就会拒绝执行，并给予错误提示。

这是个特例，覆写的方法参数列表竟然与父类不相同，这违背了覆写的定义，并且会引发莫名其妙的错误。所以读者在对变长参数进行覆写时，如果要使用此类似的方法，请找个小黑屋仔细想想是不是一定要如此。

注意　覆写的方法参数与父类相同，不仅仅是类型、数量，还包括显示形式。