1. 多态接上 2. instanceof比较操作符 instanceof 比较操作符，用于判断 对象的运行类型 是否为 XX 类型或 XX 类型的子类型【举例说明】 代码在com.stulzl.poly_detail03.包中 311 PolyDetail03 package co
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;
// }
}