19 关键字：instanceof

instanceof关键字用于判断一个引用类型变量所指向的对象是否是一个类（或接口、抽象类、父类）的实例。

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

对象 instanceof 类  ->返回boolean类型

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 InstanceofDemo01{
    public static void main(String asrgs[]){
        A a1 = new B() ;        // 通过向上转型实例化对象
        System.out.println("A a1 = new B()：" + (a1 instanceof A)) ;
        System.out.println("A a1 = new B()：" + (a1 instanceof B)) ;
        A a2 = new A() ;        // 通过向上转型实例化对象
        System.out.println("A a2 = new B()：" + (a2 instanceof A)) ;
        System.out.println("A a2 = new B()：" + (a2 instanceof B)) ;
    }
};

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() ;
        }
    }
};

public interface IObject {
}

public class Foo implements IObject{
}

public class Test extends Foo{
}

public class MultiStateTest {
        public static void main(String args[]){
                test();
        }

        public static void test(){
                IObject f=new Test();
                if(f instanceof java.lang.Object)System.out.println("true");
                if(f instanceof Foo)System.out.println("true");
                if(f instanceof Test)System.out.println("true");
                if(f instanceof IObject)System.out.println("true");
        }
}

输出结果：

true
true
true
true

 

在对象向下转型之前最好使用instanceof关键字进行验证

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

如果现在要增加新的子类，则肯定要修改fun()方法，这样一来程序就失去了灵活性，所以在程序的开发中重点的设计应该放在父类上，只要父类设计的足够合理，则开发肯定会非常的方便。

注意：一个类永远不要去继承一个已经实现好的类。而只能继承抽象类或实现接口。