代码当中体现多台性,其实据说一句话 父类引用指向子类对象
格式:
父类名称 对象名=new 子类名称();
或者
接口名称 对象名=new 实现类名称();
package duotai.lianxi; //独立文件 运行类
public class DemoTest {
public static void main(String[] args) {
//使用多态的写法
//左侧父类的引用指向了右侧子类对象
Fu test=new Zi();
test.method();
test.methodFu();
System.out.println(test.num); // 通过对象名称访问成员变量 看等号左边是谁 就优先用谁 没有就向上找
test.showNum(); //间接通过成员方法访问成员变量
}
}
====
package duotai.lianxi; //独立文件 父类
public class Fu {
int num=10;
protected void method(){
System.out.println("1111");
}
protected void methodFu(){
System.out.println("2222");
}
protected void showNum(){
System.out.println(num);
}
}
====
package duotai.lianxi; //独立文件 子类
public class Zi extends Fu{
int num=20;
@Override
protected void method() {
System.out.println("33333");
}
}
成员变量的访问
1 通过对象名称访问成员变量 看等号左边是谁 就优先用谁 没有就向上找
2 间接通过成员方法来访问
口诀:编译看左边,运行还看左边
成员方法的访问
看new 的谁 就优先用谁 没有则向上找
口诀:编译看左边,运行看右边
一 向上转型
1 对象的向上转型 其实就是多态的写法:
格式:父类名称 对象名=new 子类名称();
含义:右侧创建一个子类对象,把他当做父类来看待使用
注意事项 向上转型一定是安全的从小范围转向了大范围
类似于
double num=100;//正确 int–>double 自动类型转换
二 向下转型
其实这是一个**【还原】**的动作
格式 子类名称 对象名=(子类名称) 父类对象
含义:将父类对象 【还原】称为本类的子类对象
类似于
int num=(int)(100.0)
没有【还原】的话 类似于
int num=int(100.5)会有精度损失
package duotai.lianxi.AnianmalTest; // 独立文件
public abstract class Anianmal {
public abstract void eat();
}
====
package duotai.lianxi.AnianmalTest; //独立文件
public class Cat extends Anianmal {
@Override
public void eat() {
System.out.println("猫吃鱼");
}
public void catMouse(){
System.out.println("捉老鼠"); package duotai.lianxi.AnianmalTest;
====
public class Dog extends Anianmal { //独立文件
@Override
public void eat() {
System.out.println("狗");
}
public void catMouse(){
System.out.println("!11");
}
}
}
}
====
package duotai.lianxi.AnianmalTest; //独立文件
public class Test {
public static void main(String[] args) {
//向上转型 父类的引用指向子类的对象
Anianmal a1=new Cat();
a1.eat();
// a1.catMouse(); 错误写法
//向下还原
Cat a2=(Cat) a1;
a2.catMouse();
/**
* 错误的向下转型
* 本来new 出来的是一只猫,现在要转型为狗
* 错误写法 但是允许会出现异常
* java.lang.ClassCastException 类转换异常
Dog a3=(Dog) a1;
a3.run();
*/
}
}
如何才能知道父类引用的对象,本来是什么子类
格式:
对象 instanceof 类名称
这将会得到一个boolean结果,也就是判断前面的对象能不能当做后面类型的实例
====
public static void give(Anianmal anianmal){
if (anianmal instanceof Cat){
Cat a1=(Cat) anianmal;
a1.catMouse();
}
if (anianmal instanceof Dog){
Dog a1=(Dog) anianmal;
a1.catMouse();
}
}