【Java】你真的懂 instanceof 吗

instanceof 是用来判断左边的对象是否为右边的类的实例，返回值为布尔boolean类型；

语法：

• A instanceof B ，A是实例对象，B是类

简单来说就是：如果 左边的对象 是 右边的类 或者 右边的子类 的对象，则为 true；

先简单从一个选择题来引入：

• A：因为cat是C类的对象，而C类是B类的子类，所以返回 true；
• B：因为bird是B类的对象，而B类是C类的子类，所以返回 true；
• C：因为cat是C类的对象，而C类是B类的子类，B类又是A类的子类，所以返回 true；
• D：bird 是B类的对象，但C却是B的子类，所以bird是大，而C类是小，所以返回false；

从代码来看：

1. 先构造父类和子类；
2. 创建子类对象；
3. 判断子类对象是否属于子类或父类；

public class Demo01 {
    public static void main(String[] args) {
        Person p = new Person();
        Son  s = new  Son();
/*      boolean flag = s instanceof Person (错误，应该 左边是对象，右边是构造函数)*/
        boolean flag1=s instanceof Person;
        boolean flag2=s instanceof Son;
        System.out.println(flag1);//true
        System.out.println(flag2);//true
    }
}
class Person{//父类
}

class Son extends Person{//子类
}

注意：

• 左边对象不能是基本数据类型；
• 左边的对象实例要和右边的类在同一个继承树上；
• null 用 instanceof 跟任何类型比较时都是false；

instanceof 应用场景：

        instanceof 概念在多态中引出，因为在多态发生时，子类只能调用父类中的方法（编译时类型的方法），而子类自己独有的方法（运行时类型的方法）无法调用，如果强制调用的话就需要向下转型，语法和基本类型的强制类型转换一样；但是向下转型具有一定的风险，很有可能无法成功转化，为了判断能否成功转化，就需要 instanceof 先进行一个判断，然后再进行转换操作。

因为在实际开发中，如果需要向下转型的话，你无法保证你所要转换的可以成功，所以一定要记住：
只要是向下转型，一定要先用instanceof判断，再进行转换！！！！切记

进一步理解：
        使用 instanceof 时需要保证：instanceof 前面的引用变量编译时的类型要么与后面的类型相同，要么与后面的类型具有父子继承关系

Object test = "Hello"; // test实际类型是String，但是Object是所有类的父类
System.out.println(test instanceof Object); // 返回true ，因为test编译时时Object类，test可以是Object类实例
System.out.println(test instanceof String); // 返回true ，因为Object是String的父类，test可以是String类的实例
System.out.println(test instanceof Math); // 返回false ，因为Object是Math的父类，但是test不是Math类的实例

// 不符合instanceof语法规则：
String test02 = "Hello"; // test02是String类
System.out.println(test02 instanceof Math); // 编译出错，String类和Math类无继承关系

• instanceof 可以理解为 XX 是否是 XX：

// 抽象一个人类作为父类
class Person {
    String name;

    public void classes() {}
    public void doWork() {}
}
// 学生类
class Students extends Person {
    Students(String myName) {
        this.name = myName;
    }
    // 子类重写父类方法，覆盖了父类方法
    public void classes() {
        System.out.println(this.name + "在听课");
    }
    // 子类重写父类方法，覆盖了父类方法
    public void doWork() {
        System.out.println(this.name + "在写作业");
    }
    // 子类独有方法
    public void playing() {
        System.out.println(this.name + "在玩游戏");
    }
}
// 老师类
class Teachers extends Person {
    Teachers(String myName) {
        this.name = myName;
    }
    // 子类重写父类方法，覆盖了父类方法
    public void classes() {
        System.out.println(this.name + "在上课");
    }
    // 子类重写父类方法，覆盖了父类方法
    public void doWork() {
        System.out.println(this.name + "在改作业");
    }
    // 子类独有方法
    public void shopping() {
        System.out.println(this.name + "在逛街");
    }
}
public class PolymorphismTest02 {
    public static void main(String[] args) {
        //此处发生多态
        Person s = new Students("张三");
        Person t = new Teachers("李四");
        s.classes();
        s.doWork();
        // 无法调用students特有的方法，这时需要向下转型
        //s.playing();
        trans(s);

        // 同理Teachers
        t.classes();
        t.doWork();
        trans(t);
    }
    // 这个函数能很好的体现出为什么需要用 instancof，
    // 因为你不能确定传入函数的参数到底是Teachers还是Students
    public static void trans(Person p) {
        if (p instanceof Students) {
            Students s2 = (Students)p;
            // 通过向下转型便可以调用Students特有方法了
            s2.playing();
        }
        else if (p instanceof Teachers) {
            Teachers t2 = (Teachers)p;
            t2.shopping();
        }
    }
}

看完以上代码，你应该明白为什么需要 instanceof 了吧；

        实际开发中，如果需要向下转型的话，无法保证所要转换的可以成功，所以一定要记住：

• 只要是向下转型，一定要先用instanceof判断，再进行转换！！！！切记

• 向下转型步骤是：先判断(instanceof)，再转换(type)