1. 对象的向上转型，其实就是多态写法：
格式：父类名称 对象名 = new 子类名称();                                        

           Animal animal = new Cat();

含义：右侧创建一个子类对象，把它当做父类来看待使用。             

           创建了一只猫，当做动物看待，没问题

注意事项：

向上转型一定是安全的。从小范围转向了大范围，从小范围的猫，向上转换成更大范围的动物。

但是也有一个弊端：对象一旦向上转型为父类，那么就无法调用子类原本特有的内容。

解决方案：用对象的向下转型【还原】。

 

2.对象的向下转型，其实就是一个【还原】的动作：
格式：子类名称 对象名 = (子类名称) 父类对象；

           Animal animal = new Cat(); // 本来是猫，向上转型成为动物

含义：将父类对象，【还原】成为本来的子类对象。

           Cat cat = (Cat)animal; // 本来是猫，已经被当做动物了，还原回来成为本来的猫

注意事项：

a. 必须保证对象本来创建的时候，就是猫，才能向下转型成为猫

b. 如果对象创建的时候本来不是猫，现在非要向下转型成为猫，就会报错（java.lang.ClassCastException）。

    类似于： int num = (int) 10.0; // 可以                   int num = (int) 10.5 // 不可以，精度损失

 
3.对象的向下转型，一定要进行instanceof关键字判断：
格式：对象  instanceof  类名称

这将会得到一个Boolean值结果，也就是判断前面的对象能不能当做后面类型的实例。

 

实例如下：

创建一个父类Animal：
package DuoTai;
 
//父类Animal
 
public abstract class Animal {
 
    public abstract void eat();
 
}



创建一个子类Cat继承父类Animal：

package DuoTai;
 
//子类Cat
 
public class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
 
    //这个是子类特有方法
    public void catchMouse(){
        System.out.println("猫抓老鼠");
    }
}

创建一个子类Dog继承父类Animal：
package DuoTai;
 
//子类Dog
 
public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
 
    public void watchHouse(){
        System.out.println("狗看家");
    }
}

创建一个Demo01Main类使用父子类：
package DuoTai;
 
public class Demo01Main {
    public static void main(String[] args) {
 
        // 对象的向上转型，就是：父类引用指向子类对象
        Animal animal = new Cat();
        animal.eat();
        System.out.println("=====================");
 
//        animal.catchMouse(); // 错误写法！
 
        // 向下转型，进行【还原】动作
        Cat cat = (Cat) animal;
        cat.catchMouse();
 
        // 下面是错误的向下转型
        // 本来new的是一直猫，现在非要当做狗
        // 错误写法！编译不会报错，但是运行会出现异常
        // java.lang.ClassCastException，类转换异常
//        Dog dog = (Dog) animal;
 
    }
}


猫吃鱼
=====================
猫抓老鼠



创建一个Demo02Instanceof类使用父子类：

package DuoTai;
 
/*
如何才能知道一个父类引用的对象，本来是什么子类？
格式：
对象 instanceof 类名称
这将会得到一个boolean值结果，也就是判断前面的对象能不能当做后面类型的实例。
 */
 
public class Demo02Instanceof {
 
    public static void main(String[] args) {
        Animal animal = new Cat(); // 本来是一只猫
        animal.eat(); // 猫吃鱼
 
        //如果希望调用子类特有方法，需要向下转型
        //判断一下父类引用animal本来是不是Dog
        if(animal instanceof Dog){
            Dog dog = (Dog) animal;
            dog.watchHouse();
        }
        //判断一下animal本来是不是Cat
        if(animal instanceof Cat){
            Cat cat = (Cat) animal;
            cat.catchMouse();
        }
 
        System.out.println("==================");
 
        giveMePet(new Dog());
    }
 
    public static void giveMePet(Animal animal){
        if(animal instanceof Dog){
            Dog dog = (Dog) animal;
            dog.watchHouse();
        }
        if(animal instanceof Cat){
            Cat cat = (Cat) animal;
            cat.catchMouse();
        }
    }
}

猫吃鱼
猫抓老鼠
==================
狗看家