Java对象的向上向下转型

/**
 * 实现Animal001
 */
public class Animal002 {
    public static void main(String[] args){
        Animal001 animal001 = new Dog01();//对象的向上转型就是:父类引用指向子类对象.
        animal001.eat();//因为把猫当做动物,动物有吃这个方法,所以能实现.
        /**
         * animal001.catMice();这是一个错误的写法.
         * 1:因为把猫当做动物,现在这个动物没有这个方法,所以不能实现.
         *      不是所有动物都能实现抓老鼠这个方法.
         */
        //Cat01 cat01 = (Cat01)animal001;//向下转型,进行还原动作.
       //cat01.catMice();//运行猫特有的方法(抓老鼠);
        /**
         * 如何才能知道一个父类引用对象,本来是什么子类.
         * 格式:
         * 对象名称 instanceof 类名称;
         */
        //如果需要调用子类特有的方法,需要向下转型.
        //判断一下父类引用animal001是不是Cat01;
        if (animal001 instanceof Cat01) {
            Cat01 cat02 = (Cat01)animal001;
            cat02.catMice();
        }else if (animal001 instanceof Dog01) {//判断一下父类引用animal001是不是Dog01;
            Dog01 dog01 = (Dog01)animal001;
            dog01.dogHouse();
        }
    }
}

2:Animal001这个类

/**
 * 对象的向上转型:
 * 1:对象的向上转型,其实就是多态写法.
 * 格式:父类名称 对象名称 = new 子类名称();
 *      如:Animal animal = new Cat();创建了一只猫,把它当做动物看待.
 * 含义:右侧创建一个子类对象,把他当做父类来看待使用.
 * 注意:向上转型一定是安全的,从小范围转向了大范围.
 *      对象一旦向上转型为父类,那么就无法调用子类原本特有的内容.
 */

/**
 * 对象的向下转型(还原),其实就是一个还原的动作.
 * 格式:子类对象 对象名称 = (子类名称) 父类对象;
 *      如:Animal animal = new Cat();创建了一只猫,把它当做动物看待.
 *         Cat cat = (Cat)animal;本来就是猫了,已经被当成动物了,还原回来成为本来的猫.
 * 含义:将父类对象(还原)成为原来的子类对象.
 * 注意:必须保证对象创建的时候就是猫,才能向下转型成为猫.
 */
public abstract class Animal001 {//因为里面定义了抽象方法,所以这个必须是抽象类.
    public abstract void eat();//定义一个抽象方法
}
class Cat01 extends Animal001{
    public void eat(){//父类方法覆盖重写
        System.out.println("猫吃鱼");
    }

    public void catMice(){//子类特有的一个方法,父类没有.
        System.out.println("猫抓老鼠");
    }
}
class Dog01 extends Animal001{
    public void eat(){//父类方法覆盖重写
        System.out.println("狗吃骨头");
    }

    public void dogHouse(){//子类特有的一个方法,父类没有.
        System.out.println("狗看家");
    }
}