main 方法

public class Solution {
    public static void main(String[] args) {
        Person person = new Person();
        person.hello();
    }
}

class Person {
    public void hello() {
        System.out.println("hello");
    }
}

源文件名是 Solution.java，这是因为文件名必须与 public 类的名字相匹配。在一个源文件中，只能有一个公有类，但可以有任意数目的非公有类。

在这个示例程序中包含两个类：Person 类和带有 public 访问修饰符的 Solution 类。Solution 类包含了 main 方法。

当编译这段源代码的时候，编译器将在目录下创建两个 class 文件：Solution.class 和 Person.class。

将程序中包含 main 方法的类名提供给字节码解释器，以便启动这个程序：java Solution。字节码解释器开始运行 Solution 类的 main 方法中的代码。

理解方法调用

下面假设要调用 x.f(args)。下面是调用过程的详细描述：

• 编译时：
  1. 编译器査看对象变量的声明类型和方法名，然后获得所有可能被调用的候选方法。
  2. 编译器査看调用方法时提供的参数类型，然后获得需要调用的方法名字和参数类型。
• 运行时：
  • 如果方法是 private 方法、static 方法、final 方法或者构造器方法，那么编译器将可以准确地知道应该调用哪个方法，我们将这种调用方式称为静态绑定（static binding)。与此对应的是，调用的方法依赖于对象变量 x 的实际类型，并且在运行时实现动态绑定。
  • 虚拟机预先为每个类创建了一个方法表（method table)，方法表中列出了所有方法的签名和实际调用的方法。这样一来，在真正调用方法的时候，虚拟机仅查找方法表就行了。

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 等），所以这个过程可能很复杂。如果编译器没有找到与参数类型匹配的方法，或者发现经过类型转换后有多个方法与之匹配，就会报告一个错误。至此，编译器已获得需要调用的方法名字和参数类型。

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

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

每次调用方法都要进行搜索，时间开销相当大。因此，虚拟机预先为每个类创建了一个方法表（method table)，方法表中列出了所有方法的签名（方法名、参数类型）和实际调用的方法。这样一来，在真正调用方法的时候，虚拟机仅查找方法表就行了。

在前面的例子中，虚拟机搜索 D 类的方法表，以便寻找与调用 f(Sting) 相匹配的方法。这个方法既有可能是 D.f(String)，也有可能是 C.f(String)，这里的 C 是 D 的父类。这里需要提醒一点，如果调用 super.f(param)，编译器将对对象变量父类的方法表进行搜索。

方法调用的示例

public static void main(String[] args) {
    Employee e = new Manager("Carl Cracker", 80000, 1987, 12, 15);
    System.out.println("salary=" + e.getSalary());
}

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

由于 getSalary() 不是 private 方法、static 方法，也不是 final 方法，所以将采用动态绑定。虚拟机为 Employee 和 Manager 两个类生成方法表。

在 Employee 的方法表中，列出了这个类定义的方法。实际上，下面列出的方法并不完整，Employee 类有一个父类 Object，Employee 类从这个父类中还继承了许多方法，在此我们略去了 Object 的方法。

Employee:
    getName() -> Employee.getName()
    getSalary() -> Employee.getSalary()
    getHireDay() -> Employee.getHireDay()
    raiseSalary(double) -> Employee.raiseSalary(doubl e)

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

Manager:
    getName() -> Employee.getName()
    getSalary() -> Manager.getSalary()
    getHireDay() -> Employee.getHireDay()
    raiseSalary(double) -> Employee.raiseSalary(doubl e)
    setBonus(double) -> Manager.setBonus(double)

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

1. 首先，虚拟机提取对象变量 e 的实际类型的方法表。既可能是 Employee、Manager 的方法表，也可能是 Employee 类的其他子类的方法表。
2. 接下来，虚拟机搜索对象变量 e 的实际类型的方法表。此时，虚拟机已经知道应该调用哪个方法。
3. 最后，虚拟机调用方法。

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

参考资料

《Java核心技术卷一：基础知识》（第10版）第 5 章：继承 5.1.6 理解方法调用