Java 调用对象方法的执行过程

    弄清调用对象方法的执行过程十分重要。下面是调用过程的详细描述：

    1) 编译器查看对象的声明类型和方法名。假设调用x.f(param)，且隐式参数x声明为C类的对象。需要注意的是：有可能存在多个名为f，但参数类型不一样的方法。例如，可能存在方法f(int)和方法f(String)。编译器将会 一 一列举所有C类中名为f的方法和其超类中访问属性为public且名为f的方法。

    至此，编译器已获得所有可能被调用的候选方法。

    2) 接下来，编译器将查看调用方法时提供的参数类型。如果在所有名为f的方法中存在一个与提供的参数类型完全匹配，就选择这个方法。这个过程被称为重载解析(overloading resolution)。例如，对于调用x.f("Hello")来说，编译器将会挑选f(String),而不是f(int)。由于允许类型转换(int可以转换成double，Manager可以转换成Employee，等等)，所以这个过程可能很复杂。如果编译器没有找到与参数类型匹配的方法，或者发现经过类型转换后有多个方法与之匹配，就会报告一个错误。

    至此，编译器已获得需要调用的方法名字和参数类型。

    √ 注释：前面曾经说过，方法的名字和参数列表称为方法的签名。例如，f(int)和f(String)是两个具有相同名字，不同签名的方法。如果在子类中定义了一个与超类签名相同的方法，那么子类中的这个方法就覆盖了超类中的这个相同签名的方法。

        不过，返回类型不是签名的一部分，因此，在覆盖方法时，一定要保证返回类型的兼容性。在Java SE 5.0以前的版本中，要求返回类型必须是一样的。现在允许子类将覆盖方法的返回类型定义为原返回类型的子类型。例如，假设Employee类有

            public Employee getBuddy() { ... }

        在后面的子类Manager中，可以按照如下所示的方式覆盖这个方法

            public Manager getBuddy() { ... }

        我们说，这两个getBuddy方法具有可协变的返回类型 (covariant return types) 。

    3) 如果是private方法、static方法、final方法 或者构造器，那么编译器将可以准确地知道应该调用哪个方法，我们将这种调用方式称为静态绑定 (static binding)。于此对应的是，调用的方法依赖于隐式参数的实际类型，并且在运行时实现动态绑定(dynamic binding)。在我们列举的示例中，编译器采用动态绑定的方式生成一条调用f(String)的指令。

    4) 当程序运行，并且采用动态绑定调用方法时，虚拟机一定调用与x所引用对象的实际类型最合适的那个类的方法。假设x的实际类型是D，它是C类的子类。如果D类定义了方法f(String)，就直接调用它；否则，将在D类的超类中寻找f(String)，以此类推。

    每次调用方法都要进行搜素，时间开销相当大。因此，虚拟机预先为每个类创建了一个方法表 (method table) ，其中列出了所有方法的签名和实际调用的方法。这样一来，在真正调用方法的时候，虚拟机仅查找这个表就行了。在前面的例子中，虚拟机搜索D类的方法表，以便寻找与调用f(String) 相匹配的方法。这个方法既有可能是D.f(String)，也有可能是X.f(String)，这里的X是D的超类。这里需要提醒一点，如果调用super.f(param)，编译器将对隐式参数超类的方法表进行搜索。

    现在，查看查看一下例5-1中调用e.getSalary()的详细过程。e声明为Employee类型。Employee类只有一个名叫getSalary的方法，这个方法没有参数。因此，在这里不必担心重载解析的问题。

    由于getSalary不是private方法、static方法或final方法，所以将采用动态绑定。虚拟机为Employee和Manager两个类生成方法表。在Employee的方法表中，列出了这个类定义的所有方法：

    Employee:

        getName() -> Employee.getName()

       getSalary() -> Employee.getSalary()

        getHireDay() -> Employee.getHireDay()

       raiseSalary(double) -> Employee.raiseSalary(double)

    实际上，上面列出的方法并不完整，在此我们略去了从Object继承来的许多方法。

    Manager方法表稍微有些不同。其中有三个方法是继承而来的，一个方法是重新定义的，还有一个方法是新增加的。

    Manager:

       getName() -> Employee.getName()

       getSalary() -> Manager.getSalary()

       getHireDay() -> Employee.getHireDay()

       raiseSalary(double) -> Employee.raiseSalary(double)

        setBonus(double) -> Manager.setBonus(double)

    在运行的时候，调用e.getSalary()的解析过程为：

    1) 首先，虚拟机提取e的实际类型的方法表。既可能是Employee、Manager的方法表，也可能是Employee类的其它子类的方法表。

    2) 接下来，虚拟机搜索定义getSalary签名的类。此时，虚拟机已经知道应该调用哪个方法。

    3) 最后，虚拟机调用方法。

    动态绑定有一个非常重要的特性：无需对现存的代码进行修改，就可以对程序进行扩展。假设增加一个新类Executive，并且变量e有可能引用这个类的对象，我们不需要对包含调用e.getSalary() 的代码进行重新编译。如果e恰好引用一个Executive类的对象，就会自动地调用Executive.getSalary() 方法。

   × 警告：在覆盖一个方法的时候，子类方法不能低于超类方法的可见性。特别是，如果超类方法是public，子类方法一定要声明为public。经常会发生这类错误：在声明子类方法的时候，遗漏了public修饰符。此时，编译器将会把它解释为试图降低访问权限。

例5-1 ManagerTest.java                                                                                                   

import java.util.*;

/**
 * This program demonstrates inheritance.
 * @version 1.21 2004-02-21
 * @author Cay Horstmann
 */
public class ManagerTest
{
	public static void main(String[] args)
	{
		// construct a Manager object
		Manager boss = new Manager("Carl Craker",80000,1987,12,15);
		boss.setBonus(5000);

		Employee[] staff = new Employee[3];

		// fill the staff array with Manager and Employee objects

		staff[0] = boss;
		staff[1] = new Employee("Harry Hacker",50000,1989,10,1);
		staff[2] = new Employee("Tommy Tester",40000,1990,3,15);

		// print out information about all Employee objects
		for(Employee e:staff)
			System.out.println("name: " + e.getName() + ",salary: " + e.getSalary());
	}
}

class Employee
{
	public Employee(String n,double s,int year,int month,int day)
	{
		name = n;
		salary = s;
		GregorianCalendar calendar = new GregorianCalendar(year,month-1,day);
		hireDay = calendar.getTime();
	}

	public String getName()
	{
		return name;
	}

	public double getSalary()
	{
		return salary;
	}

	public Date getHireDay()
	{
		return hireDay;
	}

	public void raiseSalary(double byPercent)
	{
		double raise = salary * byPercent /100;
		salary += raise;
	}

	private String name;
	private double salary;
	private Date hireDay;
}

class Manager extends Employee
{
	/**
	 * @param n the employee's name
	 * @param s the salary
	 * @param year the hire year
	 * @param month the hire month
	 * @param day the hire day
	*/
	public Manager(String n,double s,int year,int month,int day)
	{
		super(n,s,year,month,day);
		bonus = 0;
	}

	public double getSalary()
	{
		double baseSalary = super.getSalary();
		return baseSalary + bonus;
	}

	public void setBonus(double b)
	{
		bonus = b;
	}

	private double bonus;
}

—— 声明：此文源自《JAVA 核心技术》5.1.3 "动态绑定"