java中，instanceof運算子的前一個操作符是一個引用變數，後一個運算元通常是一個類（可以是介面），用於判斷前面的物件是否是後面的類，或者其子類、實現類的例項。如果是返回true，否則返回false。

也就是說：

使用instanceof關鍵字做判斷時， instanceof 操作符的左右運算元必須有繼承或實現關係

專案原始碼截圖示例

if (para.containsKey(key)) {
    Object param = para.getObject(key);
    //判斷型別並賦值
    if (param instanceof Integer) {
        celltext 
 
= celltext.replace(zyq, para.getInt(key) + "");
    } else if (param instanceof String) {
        celltext = celltext.replace(zyq, para.getString(key));
    } else if (param instanceof Double) {
        celltext = celltext.replace(zyq, para.getDouble(key) + "");
    } else if (param instanceof Date) {
        celltext 
 
= celltext.replace(zyq, para.getDateToString(key, "yyyy-MM-dd"));
    } else {
        celltext = celltext.replace(zyq, para.get(key) + "");
    }
} else {
    celltext = celltext.replace(zyq, "");
}

下面我們用繼承樹來判斷instanceof的返回值：

interface Man{}
class Person1 implements Man{}    
class Student extends
 
 Person1 {}    
class Postgraduate extends Student {}    
class Animal {}    
public class Ex_instanceOf 
{    
    public static void main(String[] args) {    
       System.out.println("Student 的物件是誰的例項？");
       instanceofTest(new Student()); 
       System.out.println("Animal 的物件是誰的例項？");
       instanceofTest(new Animal());
       System.out.println("Postgraduate 的物件是誰的例項？");
       instanceofTest(new Postgraduate());
       //一個類的例項是這個類本身的例項，也是他父類，父類的父類的例項，也是實現的介面的例項
    }      
    public static void instanceofTest(Object p) {
        if (p instanceof Animal)
            System.out.println(p.getClass() + "類的例項  是類Animal的例項");
        if (p instanceof Postgraduate)
            System.out.println(p.getClass() + "類的例項  是類Postgraduate的例項");
        if (p instanceof Student)
            System.out.println(p.getClass() + "類的例項  是類Student的例項");
        if (p instanceof Person1)
            System.out.println(p.getClass() + "類的例項  是類Person的例項");
        if (p instanceof Man)
            System.out.println(p.getClass() + "類的例項  是介面Man的例項");
        if (p instanceof Object)
            System.out.println(p.getClass() + "類的例項  是類Object的例項");
 
    }
}

上面的程式，展示各類之間的關係的繼承樹是：

上述程式中：

由上面繼承樹可知，某個類（介面也可以看成一個特殊的類）的物件是不是其他類（或介面）的例項，只需按箭頭方向，以

此物件所在的類為起點到達此繼承樹分支（可能有多個分支）終點，沿途經過的類（包括本類，或介面）就都是該物件的例項。

所以輸出結果是：

Student 的物件是誰的例項？
class t20170722FromInternet.Student類的例項  是類Student的例項
class t20170722FromInternet.Student類的例項  是類Person的例項
class t20170722FromInternet.Student類的例項  是介面Man的例項
class t20170722FromInternet.Student類的例項  是類Object的例項
Animal 的物件是誰的例項？
class t20170722FromInternet.Animal類的例項  是類Animal的例項
class t20170722FromInternet.Animal類的例項  是類Object的例項
Postgraduate 的物件是誰的例項？
class t20170722FromInternet.Postgraduate類的例項  是類Postgraduate的例項
class t20170722FromInternet.Postgraduate類的例項  是類Student的例項
class t20170722FromInternet.Postgraduate類的例項  是類Person的例項
class t20170722FromInternet.Postgraduate類的例項  是介面Man的例項
class t20170722FromInternet.Postgraduate類的例項  是類Object的例項

但是，要注意一點：

在判斷某個類（介面也可以看成一個特殊的類）的物件是不是其他類（或介面）的例項，一定要首先進行向上轉型，然後才可用instanceof關鍵字進行判斷，這是基本操作規範。

如：

interface A{
    void say();
}
class B implements A{ 
    public void say()
    {
        System.out.println("B實現的say()方法");
    }
}
class C implements A{
    public void say()
    {
        System.out.println("C實現的say()方法");
    }
}
 
public class TestDemo{
    public static void main(String[] args) {
        A a= new B();  //介面不能new
        System.out.println(a instanceof B);   //true;發生了A a= new B();
            System.out.println(a instanceof C);   //false;沒有發生A a = new C();      
    }
}

以上各類的之間關係的繼承樹如下：

在判斷介面A的物件a 是不是類C的例項時，沒有先進行向上轉型，就進行instanceof關鍵字的使用了，是肯定會返回false的。

總結：
如果一個類的例項是這個類本身的例項，那麼它也是它的父類、它的父類的父類的例項，也是由它實現的介面的例項
且instanceof左邊操作元顯式宣告的型別與右邊操作元必須是同種類或右邊是左邊父類的繼承關係

此外：

//false;這是instanceof 特 有 的 規 則 ： 
//若左運算元為null， 結果就直接返回false， 不再運算右運算元是什麼類。
boolean b5 = null instanceof String; 

//編譯不通過;'A'在此處視為基本資料型別char，instanceof操作符只能用作物件的判斷
boolean b4 = 'A' instanceof Character;