instanceof的是与非

java中instanceof关键字对于final、非final类、泛型、Object、interface，在编译时的要求不同。

A、其中泛型实例可以与任何接口和类执行instanceof判断(t instanceof User / t instanceof list)；

B、interface实例可与任何对象（除final对象）执行instanceof判断(list instanceof User / list instanceof Runnable)；

C、Object实例可与任何对象执行instanceof判断(obj instanceof User / obj instanceof List)；

D、final与非final实例

D.1 同，对于类的instanceof判断，都必须要求是父类； 

D.2 异，非final类可以instanceof非实现接口，但是final类不可以；

* 根本原因在于final类没有子类，所以其实例必定是类自身，所以其实现接口和父类都是很确定的。

* 但是，非final类可以有子类，且只有一个子类。所以在对于类的instanceof判断上也是确定的，其中子类可以实现非final类没有的接口，所以编译器也就宽容的放行了。

（ 一开始以为与泛型有关，后来觉得可能与动态代理有关，最终验证得与类是否可以有子类有关）

public class InstanceofTest {

    public void finalClassTest(){
        String str = "";//final Object
        
        //父类
        if(str instanceof Object){
            //
        }

        //非父类
//        Incompatible conditional operand types String and LinkedList
//        if(str instanceof LinkedList){  }

        //实现接口
        if(str instanceof Serializable ||
                str instanceof Comparable ||
                str instanceof CharSequence){
        //
        }
        
        //非实现接口
        //编译器语法不通过
        //Incompatible conditional operand types String and Readable
//        if(str instanceof Readable){}
        
    }
    
    public  void unFinalClassTest(){
        //非final对象
        ArrayList<Object> array = new ArrayList<Object>();
        
        //非实现接口
        if(array instanceof Comparable){
            //
        }
        
        //非父类
        //编译器语法不通过
        //Incompatible conditional operand types ArrayList<Object> and String
//        if(array instanceof LinkedList){}
        
    }
    
    interface Some{}
    class Dummy{ }
    class DummyChild extends Dummy implements Some{ }
    public  void unFinalClassTest2(){
        //非final对象
        Dummy dummy = new DummyChild();
        
        //非父类实现接口，却是子类的实现接口
        if(dummy instanceof Some){
            //
        }
    }

    public <T>  void genericityClassTest(T genericityObj){
        
        if(genericityObj instanceof Comparable){ }
        
        if(genericityObj instanceof LinkedList){ }
    }
}

    public void testInterfaceOrObjInstanceof(){
        List<?> list = new ArrayList<String>();
        Object obj = new Thread();

        //接口与其它接口
        if(list instanceof Runnable){ }
        //接口与非final对象
        if(list instanceof FileInputStream){ }
        //接口与final对象
        //Incompatible conditional operand types List<capture#3-of ?> and Math
//        if(list instanceof Math){ }

        //obj与任意接口
        if(obj instanceof List){ }
        //obj与final对象
        if(obj instanceof Math){ }
        //obj与非final对象
        if(obj instanceof Float){ }
    }

<* 原创，转载请注明>