对象的向上转型和向下转型理解和举例以及instanceof关键字的用法

对象的向上转型，其实就是多态写法：

• 父类名称 对象名 = new 子类名称()
• 右侧创建一个子类对象，把它当作父类来看待使用。
• 注意事项：向上转型一定是安全的。从小范围到了大范围(new了一个子类，但是引用类型是父类)
  类似于double num = 100; 这是正确的，强制自动类型转换。

Animal animal = new Cat(); //创建了一只猫，当动物看待

对象的向下转型，其实就是还原动作

• 子类名称 对象名 = (子类名称)父类对象
• 将父类对象，还原成本来的子类对象。

Animal animal = new Cat(); //本来是猫，向上转型成动物
Cat cat = (Cat) animal; //本来是猫，已经被当成动物了，还原回来成为本来的猫

注意事项

1. 必须保证对象本来创建的时候就是猫，才能向下转型成为猫，也就是new出来的是猫
2. 如果对象创建的时候本来不是猫，现在非要转型成为猫，可以编译通过，但运行时会报错：ClassCastException
   类似于:

int num = (int)10.0; //可以
int num = (int)10.5; //不可以，因为有精度损失

如何确保向下转型的时候是安全的？

• 父类 instanceof 子类这个表达式返回的是boolean类型变量，true就是转型安全，否则就是不安全。下面我举员工这个父类下面的老师和助教两个子类的例子便于理解
• 我们使用向下转型为的就是使用某个多态子类的特有方法

public class Employee {//父类员工类
    public void work() {
        System.out.println("进行工作");
    }
}

public class Teacher extends Employee{//子类老师类
    @Override
    public void work(){
        System.out.println("上课");
    }

    public void teachAssistant(){
        System.out.println("Teaching");
    }
}

public class Assistant extends Employee{//子类助教类
    @Override
    public void work(){
        System.out.println("改作业");
    }

    public void listenTeacher(){
        System.out.println("Learning");
    }
}

public class MyInstanceof {
    public static void main(String[] args) {
        Employee teacher = new Teacher();
        Employee assistant = new Assistant();
//        teacher.teachAssistant(); 多态中子类特有方法不允许
//        assistant.listenTeacher();
        dispatch(teacher);
        dispatch(assistant);
    }

    public static void dispatch(Employee employee){
        if(employee instanceof Teacher){
            System.out.println("让老师干特有的事情");
            Teacher teacher = (Teacher) employee;
            teacher.teachAssistant();
        }else if(employee instanceof Assistant) {
            System.out.println("让助教干特有的事情");
            Assistant assistant = (Assistant) employee;
            assistant.listenTeacher();
        }
    }
}

让老师干特有的事情
Teaching
让助教干特有的事情
Learning

instanceof的另一种用法：

• 某个方法的参数用父类去接收，再在里面用instanceof判断是属于哪个子类，再根据他属于哪个子类执行相应的操作
• 注意跟上面的例子相反，我在初始化的时候没有用到多态，直接new相应的子类
• 其实例子中的对象经历的是：

1. 参数传递时向上转型，
2. 判断属于哪个子类子后的，又向下转型，因为此时判断过所属子类，就直接往子类里面转就行。安全。

public class MyInstanceof {
    public static void main(String[] args) {
        Teacher teacher = new Teacher();
        Assistant assistant = new Assistant();
        dispatch(teacher);
        dispatch(assistant);
    }

    public static void dispatch(Employee employee){
        if(employee instanceof Teacher){
            System.out.println("让老师去干活");
            employee.work();
        }else if(employee instanceof Assistant) {
            System.out.println("让助教去改作业");
            employee.work();
        }
    }
}

让老师去干活
上课
让助教去改作业
改作业

理解一下上面的例子，如果要派两个员工去干活，我们只用了一个函数就完成了，照理来说，dispatch出去的是两个不同的类型：teacher类型和assistant类型，要overload两个函数。但是我门可以让他们两个的父类去接受这个参数，得到的是一个“多态”，再通过instanceof区分他们到底是属于哪个子类，执行相应子类需要执行的操作。