关于方法重载和方法覆盖的实际调用问题

方法的重载和方法的覆盖都是对方法功能的扩展，，但是在实际调用中二者有哪些细节上的区别呢，通过两个例子来看一下。第一个例子：

public class Test1 {

	public static void main(String [] args){
		
		AA aa = new BB();
		
		test(aa);
	}
	
	public static void test(AA aa){
		
		System.out.println("a......");
	}
	
	public static void test(BB bb){
		
		System.out.println("b......");
	}
}

class AA {

}

class BB extends AA{

}

这个程序是方法的重载机制，对于aa变量来说，在编译期是AA类型，在程序运行期是BB类型，同样是test方法，一个接收AA类型的变量，一个接收BB类型的变量，究竟会调用

哪一个呢。我们先不给出答案，先看第二个例子：

public class Test2 {

	public static void main(String[] args) {
		
		A a = new B();
		
		int j = a.getI();
		
		System.out.println(j);
	}
}

class A{
	
	int i = 10;
	
	public int getI(){
		
		return i + 10;
	}
}

class B extends A{
	
	int i = 20;
	
	public int getI(){
		
		return i + 20;
	}
}

这个程序大家应该很熟悉了，结果也一目了然。这个是方法的覆盖机制，B类继承A类，重写了A类中的getI方法，a在编译期是A类型，在运行期是B类型，所以a调用的getI方法

实际上是调用了B类中的方法，所以，结果为40。这里出现一个机制叫做动态绑定机制，当引用调用对象的成员方法的时候，会发生动态绑定机制。虽然a在编译期被看作是A类

型，但是，由于a调用的getI方法是成员方法，所以会发生动态绑定机制，在程序运行期间会查看a的实际类型来判断调用哪一个类中的方法。此时，我们再看第一个例子，其

中，调用的test方法是一个静态方法，不是成员方法，所以没有发生动态绑定机制，所以不会查看变量aa的实际类型，只会看在编译期的类型，aa是AA类型，那么就会调用

test(AA aa)方法。在第一个例子中没有成员方法，所以不存在动态绑定机制，输出结果为a......。介绍完了动态绑定机制，下面我把第二个例子改动一下，去掉B类中的getI方

法，输出结果会发生什么变化呢？程序如下：

public class Test2 {

	public static void main(String[] args) {
		
		A a = new B();
		
		int j = a.getI();
		
		System.out.println(j);
	}
}

class A{
	
	int i = 10;
	
	public int getI(){
		
		return i + 10;
	}
}

class B extends A{
	
	int i = 20;	
}

我们都已经知道会发生动态绑定机制，因为a底层是B类型，所以会调用B中的getI方法，但是B类中没有getI方法，所以会调用A类中的getI方法。问题来了，getI方法中有一个

变量i，是用A中的i=10呢还是B中的i=20呢？此时，再回到动态绑定机制上来：当引用调用对象的成员方法的时候，会发生动态绑定机制。这次还是要强调成员方法，调用成员

方法的时候，才会发生动态绑定机制，调用属性的时候则不会发生，a调用A类中的成员方法，用的也是A类中的属性，而不会用B类中的20，所以程序的输出结果就变成了20。

此时，我再作一个改动，程序如下：

public class Test2 {
	
	public static void main(String [] args){
		
		M m = new N();
		
		int s = m.getI();
		
		System.out.println(s);
	}
}

class M{
	
	int i = 10;
	
	public int getI(){
		
		return getData() + 10;
	}
	
	public int getData(){
		
		return i;
	}
}

class N extends M{
	
	int i = 20;
	
	public int getI(){
		
		return getData() + 20;
	}
	
	public int getData(){
		
		return i;
	}
}

这个程序我不做讲解了，结合动态绑定机制，我想大家肯定能够猜出程序运行结果是什么，如果我再把N类中的getData方法拿掉呢，会出现什么情况呢，呵呵，留给大家自

己解决吧。