一道比较绕的面试题

朋友遇到的面试题，供大家拍砖
class Base{
void iam(Base b){
System.out.println("i am base base");
}
void iam(Child b){
System.out.println("i am base child");
}
}

class Child extends Base{
void iam(Base b){
System.out.println("i am child base");
}
void iam(Child b){
System.out.println("i am child child");
}
}

public class Test{
public static void main(String[] args) {
Base[] test = new Base[]{new Child(), new Child()};
for (int i = 0; i < test.length; i++) {
test[i].iam(test[i]);
}
}

}

override, overload, covariance
诡异度较高的covariance.

Covariance means that the type of arguments, return values, or exceptions of overriding methods can be subtypes of the original types.
Java
Exception covariance has been supported since the introduction of the language. Return type covariance is implemented in the Java programming language version J2SE 5.0. Parameter types have to be exactly the same (invariant) for method overriding, otherwise the method is overloaded with a parallel definition instead.
编译器根据参数类型进行猜测。猜得到，它就猜。猜不到，它就让你编译不过。
上面的，编译器能猜得到。
编译器才不管你运行的时候，真正的类型是什么。
它只按字面意思理解。你定义的参数，对应的变量是什么类型。它就选什么类型。如果两个类型都匹配，那么就猜更具体的类型。
如果都猜不到，那么就让你编译不过，说你是 含糊不清，二义性，ambiguous

我觉得关键在于：

Base[] test = new Base[]{new Child(), new Child()};

　
这一句，因为Child　己向上转型为Base，所以，执行的是：

　　　

　void iam(Base b) {
		System.out.println("i am child base");
	}

因为new 的对象为Child,所以Override了父类的

　void iam(Base b) {
		System.out.println("i am child base");
	}

所以最终打印出来的是：

　　i am child base
　　i am child base

其实做对这道题的必要条件是要理解JAVA数组声明和创建对象的语义。Base[] test = new Base[]{new Child(), new Child()}; 这条语句的意思是“创建一个名称为test，长度为2，元素类型为Base的数组，但实际向元素中赋的是Child类的对象”。这条语句等价于下面两条：
Base[] test = { new Child(), new Child() };
或
Base[] test = new Base[2]; (创建一个名称为test，长度为2，元素类型为Base的数组)
test[0] = new Child();(向元素中赋的是Child类的对象)
test[1] = new Child();(向元素中赋的是Child类的对象)
故下面的结果就顺理成章了：
test[0].iam(test[0])等价于Child.iam(child)
test[1].iam(test[1])等价于Child.iam(child)
所以输出
i am child base
i am child base

对不起，用词不当：改为

其实做对这道题的必要条件是要理解JAVA数组声明和创建对象的语义。Base[] test = new Base[]{new Child(), new Child()}; 这条语句的意思是“声明一个名称为test，长度为2，元素类型为Base的数组，但实际向元素中赋的是Child类的对象”。这条语句等价于下面两条：
Base[] test = { new Child(), new Child() };
或
Base[] test = new Base[2]; (声明一个名称为test，长度为2，元素类型为Base的数组)
test[0] = new Child();(向元素中赋的是Child类的对象)
test[1] = new Child();(向元素中赋的是Child类的对象)
故下面的结果就顺理成章了：
test[0].iam(test[0])等价于Child.iam(child)
test[1].iam(test[1])等价于Child.iam(child)
所以输出
i am child base
i am child base