多态向上转型与向下转型

代码当中体现多台性，其实据说一句话父类引用指向子类对象
格式：
父类名称对象名=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();
        }
    }

多态 向上转型与向下转型

猜你喜欢

多态向上转型与向下转型