Java动态绑定机制

Java动态绑定机制

A.class

public class A {
    public int i = 10;

    public int sum() {
        return getI() + 10;
    }

    public int sum1() {
        return i + 10;
    }

    public int getI() {
        return i;
    }
}

B.class

public class B extends A {
    public int i = 20;

    public int sum() {
        return i + 20;
    }

    public int getI() {
        return i;
    }

    public int sum1() {
        return i + 10;
    }
}

Test.class

public class Test {
    public static void main(String[] args) {
        A a = new B();// a对象 的编译类型是A，运行类型是B

        /*
        测试如果子类中没有这个方法。
         */
        System.out.println(a.sum());
        // 首先编译是通过的。
        // a对象的运行类型为B类，首先在B类中找这个方法。
        // B类中不存在，根据继承机制，在A中找
        // public int sum() {
        //        return getI() + 10;
        // }
        // 在此部分中getI方法父类中有，子类中也有，继续使用动态类型绑定。
        // 在B中找此方法，返回的是20。再加上10  结果为30
        System.out.println(a.sum1());
        // 同上方法调用的是A类中的sum1方法。
        //但是i属于属性范畴，不进行动态绑定，所以i的值为10  最红结果为20

        /*
        测试如果父类中没有这个方法。
         */
        //System.out.println(a.sum());
        //System.out.println(a.sum1());
        //因为编译类型为A类 ，A类中没有这两方法，所以编译不通过。

        /*
        测试如果父子类中都有方法
         */
        //System.out.println(a.sum());
        // 调用的是方法所以是运行的是B类中的方法
        //public int sum(){
        //        return i+ 20;
        //    }
        // 调用对象属性时候，没有动态绑定机制。所以这里的i是调用方法B类中的i
        // 所以结果为20+20  = 40

        //System.out.println(a.sum1());
        // 调用的是方法，运行类型为B类中的方法。
        // public int sum1() {
        //        return i + 10;
        //    }
        //    i的道理同上   所以i为20  返回结果为20+10 = 30


    }
}

知识点总结：

• 编译类型和运行类型。

1. 定义对象时：左边的是编译类型，右边的是运行类型。
2. 运行方法看的是运行类型，属性取值看的是变异类型。

• 向上转型和向下转型

1. 向上转型 父类 对象名1 = new 子类;
2. 子类 对象名2 = (子类) 对象名1

• Java动态绑定机制

1. 调用对象方法时，方法和对象与运行类型绑定
2. 调用对象属性时，没有动态绑定机制。