Java中派怎么打出来,Java中的方法分派

Java中的方法分派

程序设计中，许多时候把不同的函数命名成名字相同可以更清晰地表达出语义。相同的方法名字，需要根据方法的参数、调用者等信息来确定到底应该执行哪个方法。这个确定执行哪个方法的过程就是方法分派。

众所周知，Java是一门面向对象语言，为我们提供了重载和重写的机制。那么，在重载和重写的背后是一个怎样的原理或者原则呢？今天通过实验来揭示

一，静态分派

假设，有如下的几个类和方法，并且接下来的一系列实验也都基于这些类和方法：

public void sayHello(Human human){

System.out.println("human say hello!");

}

public void sayHello(Man man){

System.out.println("man say hello.");

}

private static class Human{

public void sayHello(){

System.out.println("say hello in human");

}

public void eat(Fruit fruit){

System.out.println("human eat fruit.");

}

public void eat(Apple apple){

System.out.println("human eat apple.");

}

}

private static class Man extends Human{

public void sayHello(){

System.out.println("say hello in man");

}

public void eat(Fruit fruit) {

System.out.println("man eat fruit.");

}

public void eat(Apple apple) {

System.out.println("man eat apple.");

}

}

private static class Fruit{}

private static class Apple extends Fruit{}

来看一个简单的静态分派的例子

public void overload(){

Human human = new Human();

Human man = new Man();

Man realMan = new Man();

sayHello(human);

sayHello(man);

sayHello(realMan);

}

这段代码唯一不太确定的就是sayHello(man)到底调用哪个目标方法，man是一个子类的类型，但却是一个父类类型的引用。最终虚拟机选择的是sayHello(Human)方法，也就是说，在静态分派阶段，虚拟机是根据引用的类型来判断调用哪个重载方法的。实际上，静态分派是在编译期完成的，调用哪个重载方法在编译期就已经确定，如刚刚的sayHello(man)语句，经过编译器的编译会把sayHello(Human)做为调用目标写入到invokevirtual指令的参数中。

静态分派还有一个特点，如果编译期没有找到确切的重载方法，则会尝试找到一个更加合适的版本。如刚才的例子中，把sayHello(Man)方法注释掉，sayHello(realMan)还是可以成功执行，只不过此时执行的目标方法为sayHello(Human)。也就是说，编译期找到了参数为Man的父类的重载方法。但是，若一个类型父类或实现的接口不止一个，而当前类中又分别有以其父类活接口类型作为参数的重载方法，编译期会默认选择其中一个吗？当然不会，这样就会出现语义上的歧义，编译器的选择是报出错误，编译不通过。如下面的例子：

public class AmbiguousDispatch {

private interface Eater{}

private interface Drinker{}

//同时继承子类和实现接口是一样的，也会报错

private class Human implements Eater,Drinker{}

public void serve(Eater eater){}

public void serve(Drinker drinker){}

@Test

public void ambiguous(){

Human human = new Human();

//serve(human);

}

}

如果代码中注释的serve(human)放开的话，编译器会提示Ambiguous Method Call。因为它不知道该调用哪个方法，不知道这个人是按吃货算还是按酒鬼算~

二，动态分派

方法的动态分派发生在执行阶段，虚拟机根据执行方法的实际类型来判断执行哪个目标方法。

public void dynamicDispatch(){

Human man = new Man();

Human human = new Human();

Man realMan = new Man();

human.sayHello();

man.sayHello();

realMan.sayHello();

}

对于任何一个Java程序员，都会准确的推断出这段代码的结果。父类和子类都实现了相同的方法，在编译期不能确定执行父类中的方法还是执行子类中复写的方法，而需要到运行期知道了执行方法的具体类型才会判断出目标方法。如man.sayHello(),man是一个Human类型的引用，它的实际类型是Man而且可能会发生变化，到了运行期已经可以确切的知道了它的实际类型就是Man,所以会期限Man中复写的sayHello方法。

如果，方法的调用过程既有静态分派又有动态分派，则会按顺序先进行静态分派，然后再进行动态分派。

三，静态方法

在Java中，静态方法同样也可以继承，可以重载。那么它是怎么分派的呢?先看下面的实验

public class StaticMethod { private static class Human{

public static void sayHello(){

System.out.println("human say hello.");

}

}

private static class Man extends Human{

public static void sayHello(){System.out.println("man say hello");}

//public void sayHello(){}

}

@Test

public void callMethod(){

Human.sayHello();

Man.sayHello();

Human human = new Human();

Human man = new Human();

Man realMan = new Man();

human.sayHello();

man.sayHello();

realMan.sayHello();

}

}

静态方法可以通过类名直接访问，子类会继承父类的静态方法，但是不会复写父类方法。如果子类声明了和父类一样的方法，则这时候发生的是隐藏，而不是复写。因为静态方法是属于类的，即使是通过类的实例调用，最终生成的字节码指令也是invokestatic，目标方法是在编译期就已经确定好的。同时子类的实例方法也不能复写父类中的静态方法，编译器会报错。上面例子的结果为：

human say hello.

man say hello

human say hello.

human say hello.

man say hello

四，虚方法表

大多数的虚拟机动态分派时，都会利用虚方法表查找目标方法。我们知道，子类会继承父类中的方法，还有可能复写其中的方法。虚方法表中存放的就是当前类中所有方法的实际入口地址。如果方法直接继承自父类则子类中的方法入口地址与父类的相同，都是父类中方法的入口地址。如果子类复写了父类中的方法，则它的虚方法表中的入口地址就是自己复写后的方法的入口地址。运行阶段，虚拟机只需要查找实际类型中的虚拟方法表，就可以得到最终的目标方法入口地址。