package someTest;

class SSSuperClass{}
class SSSubClass extends SSSuperClass{}

public class TestDuplicate {

	public void function(Object o){				//方法1
		System.out.print("Object\n");
	}
	
	public void function(int[] array){			//方法2
		System.out.print("int[] array\n");
	}
	
	public void function(SSSuperClass array){	//方法3
		System.out.print("SSSuperClass\n");
	}
	
	public void function(SSSubClass array){		//方法4
		System.out.print("SSSubClass\n");
	}
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		new TestDuplicate().function(new Object());			//调用1
		new TestDuplicate().function(new int[3]);			//调用2
		new TestDuplicate().function(new SSSubClass());		//调用3
		new TestDuplicate().function(new SSSuperClass());	//调用4
		/**
		 * 一切都看似很和谐。参数重载可以允许父类和子类关系的存在，
		 * 调用的时候会根据实际的参数，寻找最为精确匹配的那个函数去执行。
		 * 如果我们去掉方法4，调用4就会发现方法3才是它最匹配的函数，所以调用之。
		 * 如果去掉方法3，调用4会发现方法1才是自己的实参最匹配的函数，所以调用之。
		 * */
		
		/**
		 * 但是如果我们传入的不是数组，也不是任何对象，而是一个null呢？？？
		 * 同样null也会找一个最为精确匹配的函数，但是这里会编译错误。因为这边有两条继承
		 * 路径，一个是Object->array[]，一个是Object->SSSuperClass->SSSubClass。
		 * 所以方法2和方法4，null就不知道哪个才是最精确的匹配了。
		 * 所以我们方法3和方法4在下面的调用下不兼容，有歧义。
		 * */		
		//new TestDuplicate().function(null);	//compile error
		
		//可以看到null虽然是对象，但是却什么都不是，甚至连Object都不是，但是他依然会寻找最为匹配的形参
		String s = null;
		String ss = "sss";
		if(s instanceof String) System.out.print("s is String");
		if(ss instanceof String) System.out.print("ss is String");
		if(null instanceof Object) System.out.print("null is a Object");
	}
}