instanceof关键字

1）掌握instanceof关键字的作用及使用时机

2）可以使用instanceof对对象的转型进行安全验证。

在java中可以使用instanceof关键字判断一个对象到底是哪个类的实例。

对象instanceof类 -->返回boolean类型

package methoud;
class A{                    // 定义类A
    public void fun1(){        // 定义fun1()方法
        System.out.println("A --> public void fun1(){}") ;
    }
    public void fun2(){
        this.fun1() ;        // 调用fun1()方法
    }
};
class B extends A{
    public void fun1(){        // 此方法被子类覆写了
        System.out.println("B --> public void fun1(){}") ;
    }
    public void fun3(){
        System.out.println("B --> public void fun3(){}") ;
    }
};
public class ThisDemo06{
    public static void main(String asrgs[]){
        A a1 = new B() ;        // 通过向上转型实例化对象
        System.out.println("A a1 = new B()：" + (a1 instanceof A)) ;//判断a1是不是A的实例
        System.out.println("A a1 = new B()：" + (a1 instanceof B)) ;//判断a1是不是B的实例
        A a2 = new A() ;       
        System.out.println("A a2 = new B()：" + (a2 instanceof A)) ;//判断a2是不是A的实例
        System.out.println("A a2 = new B()：" + (a2 instanceof B)) ;//判断a2是不是B的实例
    }
};
运行结果：
A a1 = new B()：true　　　　 
A a1 = new B()：true
A a2 = new B()：true
A a2 = new B()：false

使用instanceof关键字可以做什么呢？

从之前讲解的代码中可以发现一个问题。

class A{                    // 定义类A
    public void fun1(){        // 定义fun1()方法
        System.out.println("A --> public void fun1(){}") ;
    }
    public void fun2(){
        this.fun1() ;        // 调用fun1()方法
    }
};
class B extends A{
    public void fun1(){        // 此方法被子类覆写了
        System.out.println("B --> public void fun1(){}") ;
    }
    public void fun3(){
        System.out.println("B --> public void fun3(){}") ;
    }
};
class C extends A{
    public void fun1(){        // 此方法被子类覆写了
        System.out.println("C --> public void fun1(){}") ;
    }
    public void fun5(){
        System.out.println("C --> public void fun5(){}") ;
    }
};
public class InstanceofDemo02{
    public static void main(String asrgs[]){
        fun(new B()) ;
        fun(new C()) ;
    }
    public static void fun(A a){
        a.fun1() ;
　　　　 调用各自类中的方法。

        }
    }
};

如果现在传入的实例是B的实例，则要调用fun3()方法，如果是C类的实例，则要调用fun5()方法。

如果简单的向下转型就会出错。

public class InstanceofDemo02{
    public static void main(String asrgs[]){
        fun(new B()) ;
        fun(new C()) ;　　　　//对于new C()向下转型会出现错误异常。
    }
    public static void fun(A a){
        a.fun1() ;
        B b = (B) a ;　　　　//对于new C()向下转型会出现错误异常。
　　　　 b.fun3() ; 
　　} 
　　}; 

利用instanceof判断实例是属于什么类就能解决向下转型的问题，分情况向下转型。

class A{                    // 定义类A
    public void fun1(){        // 定义fun1()方法
        System.out.println("A --> public void fun1(){}") ;
    }
    public void fun2(){
        this.fun1() ;        // 调用fun1()方法
    }
};
class B extends A{
    public void fun1(){        // 此方法被子类覆写了
        System.out.println("B --> public void fun1(){}") ;
    }
    public void fun3(){
        System.out.println("B --> public void fun3(){}") ;
    }
};
class C extends A{
    public void fun1(){        // 此方法被子类覆写了
        System.out.println("C --> public void fun1(){}") ;
    }
    public void fun5(){
        System.out.println("C --> public void fun5(){}") ;
    }
};
public class InstanceofDemo02{
    public static void main(String asrgs[]){
        fun(new B()) ;
        fun(new C()) ;
    }
    public static void fun(A a){　　　　　　//向上转型
        a.fun1() ;
        if(a instanceof B){
            B b = (B) a ;　　　　//向下转型
            b.fun3() ;
        }
        if(a instanceof C){
            C c = (C) a ;
            c.fun5() ;
        }
    }
};

　　在开发中，一定要注意，对于向下转型操作，最好增加验证，以保证转型时不会发生ClassCastException异常。

　　如果现在要增加新的子类，则肯定要修改fun方法，这样一来程序失去了灵活性，所以在程序开发中，重点的设计应该放在

父类上，只要父类设计的合理，则开发肯定会非常方便。

　　在开发中记住以下一点，

1）一个类永远不要去继承一个已经实现好的类，（如这里的A类就是已经实现好的）

而只能继承抽象类或实现接口。

总结

　　1）instanceof用于判断一个对象是否是某个类的实例。

　　2）在对象转型之前最好使用instanceof关键字进行验证。