多态和动态绑定是什么关系？

本文共计790个文字，预计阅读时间需要4分钟。

1. 多态概念介绍

2.instanceof比较操作符，用于判断对象的运行时类型是否为XX类型或XX类型的子类【举例说明】

代码位于com.stulzl.poly_detail03.PolyDetail03包中的311_PolyDetail03.java

1. 多态接上

2. instanceof比较操作符

instanceof 比较操作符，用于判断对象的运行类型是否为 XX 类型或 XX 类型的子类型

代码在com.stulzl.poly_detail03.包中 311

PolyDetail03

package com.stulzl.poly_detail03; //instanceof 比较操作符，用于判断对象的运行类型是否为 XX 类型或 XX 类型的子类型 public class PolyDetail03 { public static void main(String[] args) { //重点理解：判断对象的运行类型是否为 XX 类型或 XX 类型的子类型 BB bb = new BB(); System.out.println(bb instanceof BB);//true System.out.println(bb instanceof AA);//true //aa 编译类型AA 运行类型是BB AA aa = new BB(); System.out.println(aa instanceof AA);//true System.out.println(aa instanceof BB);//true Object obj = new Object(); System.out.println(obj instanceof AA);//false String str = "hello"; System.out.println(str instanceof Object);//true } } class AA{//父类 } class BB extends AA{//子类 }

3. 多态的练习

3.1 例1 312

请说出下面的每条语言，哪些是正确的，哪些是错误的，为什么?

3.2 例2 313

判断输出

package com.stulzl.polyexercise; public class PolyExercise { public static void main(String[] args) { Sub s = new Sub(); System.out.println(s.count);//20 s.display();//20 Base b = s;//这里相当于多态 Base b = new Sub;向上转型 System.out.println(b==s);//true//相当于判断地址，二者都指向Sub，地址一样 System.out.println(b.count);//10 b.display();//20 } } class Base{//父类 int count=10; public void display(){ System.out.println(this.count); } } class Sub extends Base{//子类 int count =20; public void display(){ System.out.println(this.count); } }

4. java动态绑定机制(非常重要) 314

当调用对象方法的时候，该方法会和该对象的内存地址/运行类型绑定

当调用对象属性时，没有动态绑定机制，哪里声明那里使用

4.1 问题引入判断输出

代码在com.stulzl.dynamic_binding.包中

DynamicBinding

package com.stulzl.dynamic_binding; //动态绑定机制 314 public class DynamicBinding { public static void main(String[] args) { //a 的编译类型 A, 运行类型 B A a = new B();//向上转型 //当调用对象方法的时候，该方法会和该对象的内存地址/运行类型绑定 //?40 再注销B类中的sum时 产生动态绑定 父类中的sum()方法包括了 getI()方法由于 // 产生动态绑定 此getI()方法调用子类getI() 即 20+10 30 System.out.println(a.sum()); //当调用对象属性时，没有动态绑定机制，哪里声明那里使用 //?30 再注销B类中的sum1时 属性不会产生动态绑定 继续使用父类 sum1() // 即 return i + 10;//10 + 10 20 System.out.println(a.sum1()); } } class A {//父类 public int i = 10; //动态绑定机制: public int sum() {//父类 sum() return getI() + 10; //20 + 10 } public int sum1() {//父类 sum1() return i + 10;//10 + 10 } public int getI() {//父类 getI return i; } } class B extends A { //子类 public int i = 20; // public int sum() { // return i + 20; // } public int getI() {//子类 getI() return i; } // public int sum1() { // return i + 10; // } }