静态绑定：又称“前期绑定”，发生在编译期； 主要是方法重载（overload）； 在编译阶段，javac编译器会根据参数的静态类型决定使用哪个重载版本。
动态绑定：又称“后期绑定”，发生在运行期； 主要是方法重写（override）； 在运行阶段，Java虚拟机根据参数的实际类型决定调用哪个重写版本，查找的顺序是从子类->父类，直到找到该方法的声明为止；如果在层次结构的任何类中都找不到该方法，则虚拟机抛出错误信息。

（1）静态绑定：
示例：

public class TestDispatch {
    static abstract class Human{

    }
    static class Man extends Human{

    }
    static class Woman extends Human{

    }

    public void sayHello(Human guy){
        System.out.println("Hello,guy!");
    }
    public void sayHello(Man guy){
        System.out.println("Hello,gentleman!");
    }
    public void sayHello(Woman guy){
        System.out.println("Hello,lady!");
    }

    public static void main(String[]args){
        //实际类型变化
        Human man=new Man();
        Human woman=new Woman();

        TestDispatch td=new TestDispatch();

        //静态类型变化
        td.sayHello(man);
        td.sayHello(woman);
    }

}

运行结果：

Hello,guy!
Hello,guy!

解释：上面代码中的”Human”称为变量的静态类型，“Man”和“Woman”称为变量的实际类型。两者的区别是：静态类型的变化只发生在使用时，变量本身的静态类型不会发生改变，最终的静态类型在编译期是可知的；而实际类型的变化的结果在运行期才能确定。
在编译阶段，javac编译器在重载时会根据参数的静态类型决定使用哪个重载版本，同时静态类型在编译期又是可知的，所以选择了sayHello(Human)作为调用目标。

其他：虽然编译器能确定出方法的重载版本，但是很多时候这个重载版本并不是唯一的，所以往往只是确定一个“更合适”的版本作为最终版本。

（2）动态绑定：
示例：

public class TestDynamicDispatch {
    static abstract class Human{
        protected abstract void sayHello();
    }
    static class Man extends Human{

        public void sayHello(){
            System.out.println("Hello,gentleman!");
        }
    }
    static class Woman extends Human{
        public void sayHello(){
            System.out.println("Hello,lady!");
        }
    }

    public static void main(String[]args){
        Human man=new Man();
        Human woman=new Woman();
        man.sayHello();
        woman.sayHello();
        man=new Woman();
        man.sayHello();
    }
}

运行结果：

Hello,gentleman!
Hello,lady!
Hello,lady!

解释：上面的代码中调用sayHello（）方法时根据new创建的实际对象确定调用该对象内的该方法。

补充：Java语言中方法重写的本质：在运行期确定对象的实际类型。

———————————我是平凡的分割线———————————————————-

欢迎各位大神在下方留言赐教，小树不胜感激。