java中的静态绑定与动态绑定
个人学习记录，欢迎大家指导
什么是多态？
一个引用变量，它可以引用任何子类的对象，这个引用变量是多态的。
绑定
将一个方法调用与对应方法主体关联起来被称为绑定。（也就是，执行一条方法调用语句时所对应执行的方法体，叫做该方法体和这条方法调用语句绑定了）
动态绑定
来看一段代码
public class Parent {
public void m(){
System.out.println("父类方法执行");
}
public static void main(String[] arg){
List<Parent> list = Arrays.asList(new A(),new B(),new C());
for(Parent p : list){
p.m();
}
}
}
class A extends Parent{
public void m(){
System.out.println("A类方法执行");
}
}
class B extends Parent{
public void m(){
System.out.println("B类方法执行");
}
}
class C extends Parent{
public void m(){
System.out.println("C类方法执行");
}
}
output:
A类方法执行
B类方法执行
C类方法执行
何为动态绑定？
上述代码中，第一次循环，p变量接受一个A对象，p.m()语句调用A的m()方法，第二次循环时，p变量接受一个B对象，p.m()语句调用B的m()方法，第三次循环时，p变量接受一个C对象，p.m()语句调用C的m()方法，3次循环都是执行的p.m()语句，每次循环p.m()语句绑定的方法体不一样，这种运行时根据变量p实际引用对象动态绑定方法体的方式，叫做动态绑定。动态绑定是为了执行子类重写的方法。
静态绑定
对于static、final、private修饰的方法，以及构造方法，这些方法不可被子类重写，它们采用静态绑定。
方法调用的具体过程
看一段代码
public class Fu {
public void m(Object obj){
System.out.println("父类Object方法执行");
}
public static void main(String[] args){
Fu f = new Zi();
f.m(1);
}
}
class Zi extends Fu{
public void m(Object obj){
System.out.println("子类Object方法执行");
}
public void m(Integer i){
System.out.println("子类Integer方法执行");
}
}
output:
子类Object方法执行
为啥选择子类的m(Object)方法执行，而不是m(Integer)方法执行呢，你肯定想说因为向上转型，不能执行子类特有的方法，确实是这样，但为什么呢？
- 来看一下方法调用的过程
编译期：
1、编译器根据变量f声明的类型Fu，去Fu类中查找名字为m的方法。
2、此时可能找到多个名为m的方法，因为方法是可以重载的，编译器再根据调用方法时提供的参数类型，去找到最匹配的方法，在这里是m(Object)方法，
这个过程叫做重载解析。重载解析后，编译器获得了方法的签名（方法名+形参类型）。
3、如果方法是被static、final、private修饰的，该方法不能被重写，f.m(1)运行时，无论f引用什么子类对象，都是执行的父类的方法，此时可以确定运行时无论f的对象是什么都是执行父类中的方法，绑定Fu类中的m(Object)方法。此为前期绑定，也叫静态绑定，是编译期时发生的绑定。
4、如果方法不被static、final、private修饰，编译器采用动态绑定，记录方法签名m(Object)。
运行期：
执行f.m(1)字节码时
1、如果是静态绑定，直接执行绑定的方法，不关心对象类型。
2、如果是动态绑定，编译期只确定了方法签名，方法所在类未确定，根据f引用对象的实际类型，去该类型中找到签名为m(Object)的方法，执行该方法，此时运行时才把方法调用与具体方法体关联起来。
动态绑定就是运行的时候才决定执行哪个方法体，静态绑定在编译期就确定了要执行的方法体。
动态绑定在编译期确定执行的方法签名，在运行期确定执行哪个类的方法，实现自由执行子类重写的方法。静态绑定在编译期决定执行哪个类中的哪个方法，因为这些方法不能被重写，子类对象调用也是调用的父类中的，可以明确方法体，对于这类不能重写的方法，采用静态绑定性能更好，虽然采用动态绑定也能实现。
一个静态绑定的例子
public class Fu {
private void m(){
System.out.println("父类private方法执行");
}
public static void main(String[] args){
Fu f = new Zi();
f.m();
}
}
public class Zi extends Fu{
public void m(){
System.out.println("子类public方法执行");
}
public static void main(String[] args){
Fu f = new Zi();
// f.m(); 无法编译
}
}
output:
父类private方法执行
补充一个继承泛型类的例子
public class GenericClazz<T> {
public void m(T t){
System.out.println("泛型类中m()方法执行");
}
}
public class Zi extends GenericClazz<Integer>{
public void m(Integer i){
System.out.println("子类中m()方法执行");
}
// public void m(Object i){
// System.out.println("子类中m()方法执行");
// } 无法编译
public static void main(String[] args){
GenericClazz f = new Zi();
f.m(1);
}
}
output:
子类中m()方法执行
泛型类中，由于有泛型擦除，T实际会被在编译时替换为Object类型，那么Zi类继承GenericClazz类就是继承的m(Object）方法，而m(Integer）是对m(Object)的重载而不是重写，在用f.m(1)调用时，按照上面的理论，运行时应该是调用的Zi类中的m(Object）方法，而m(Object)子类没有重写，应该走父类语句，但是这里却走了子类的m(Integer)方法，原因是编译器自动在子类做了m(Object)方法的重写，会执行类似下面的语句：
public void m(Object t){
m((Integer) t);
}
让m(Integer)看起来就像是重写的父类的m(Integer)一样，并且还关闭了子类对m(Object)的手动重写，可以看到上面手动重写m(Object)编译是报错的。
