动态绑定与静态绑定

在java中存在静态绑定与动态绑定的问题：

• 属性的重写：为静态绑定，在编译时通过声明确定值。

• 方法的重写：为动态绑定，运行时确定为哪个对象的方法。

• 方法的重载：为静态绑定，在编译时候判断参数。

• 以下为一个实例：

package dataStrutcure;

public class BindingTest {
    public static void main(String args[])
    {
        //f为Father类型，指向Sun对象
        Father f = new Sun();
        //此时输出1,因为a为属性，虽然被重写，但是编译时发现声明已经确定为Father类的a。
        System.out.println(f.a);
        Sun s1 = new Sun();
        //同理此时输出2
        System.out.println(s1.a);
        //print方法为重写方法，运行时绑定，发现为Sun对象的print方法
        f.print();
        String str = new String("micro");
        Father f2 = new Father();
        //方法的重写编译时发现为string对象绑定到print(String str)方法
        f2.print(str);//输出"为父类string对象"
        //重载遇上了重写,首先编译时绑定到对应参数的string方法，再运行时确定子类还是父类的方法。
        Father s2 = new Sun();
        s2.print(str);


    }
}

class Father
{
    int a = 1;
    public void print()
    {
        System.out.println("a的值为" + a);
    }
    public void print(Object ob)
    {
        System.out.println("为父类object对象");
    }
    //方法重载
    public void print(String str)
    {
        System.out.println("为父类string对象");
    }


    }
class Sun extends Father
{
    int a = 2;
    @Override
    public void print() {
        // TODO Auto-generated method stub
        System.out.println("a的值为" + a);
    }
    //方法重写
    public void print(String str)
    {
        System.out.println("为子类string对象");
    }

    }

• 实例2:

public class Test5 {
    /**
     * @param args
     */
    public static void main(String args[])
    {
        A a1 = new A();
        A a2 = new B();
        B b = new B();
        C c = new C();
        D d = new D();
        //静态绑定方法2
        System.out.println(a1.f(b));//输出"A and A";
        //静态绑定方法2
        System.out.println(a1.f(c));//输出"A and A";
        //静态绑定方法1
        System.out.println(a1.f(d));//输出"A and D";
        //静态绑定方法2，再动态绑定方法4
        System.out.println(a2.f(b));//输出"B and A";
        //静态绑定方法2，再动态绑定方法4
        System.out.println(a2.f(c));//输出"B and A";
        //静态绑定方法1
        System.out.println(a2.f(d));//输出"A and D";
        //静态绑定方法3
        System.out.println(b.f(b));//输出"B and B";
        //静态绑定方法3
        System.out.println(b.f(c));//输出"B and B";
        //静态绑定方法1
        System.out.println(b.f(d));//输出"A and D";


    }
}
class A
{
    public String f(D obj)   //方法1
    {
        return "A and D";
    }
    public String f(A obj)   //方法2
    {
        return "A and A";
    }
    }
class B extends A    //B对象有方法1,3,4
{
    public String f(B obj)   //方法3
    {
        return "B and B";
    }
    public String f(A obj)   //方法4
    {
        return "B and A";
    }
    }
class C extends B
{}
class D extends B
{}