Java中的instanceof關鍵字

　　Java中，instanceof運算符的前一個操做符是一個引用變量，後一個操做數一般是一個類（能夠是接口），用於判斷前面的對象是不是後面的類，或者其子類、實現類的實例。如

果是返回true，不然返回false。

　　也就是說：

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

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

 1 package instanceofTest;
 2 
 3 /**
 4  * @author zsh
 5  * @company wlgzs
 6  * @create 2019-03-21 19:55
 7  * @Describe 繼承樹來判斷instanceof的返回值
 8  */
 9 interface Man{}
10 class Person1 implements Man{}
11 class Student extends Person1{}
12 class Postgraduate extends Student {}
13 class Animal {}
14 public class Main1 {
15     public static void main(String[] args) {
16         System.out.println("Student 的對象是誰的實例？");
17         instanceofTest(new Student());
18         System.out.println("Animal 的對象是誰的實例？");
19         instanceofTest(new Animal());
20         System.out.println("Postgraduate 的對象是誰的實例？");
21         instanceofTest(new Postgraduate());
22         //一個類的實例是這個類自己的實例，也是他父類，父類的父類的實例，也是實現的接口的實例
23     }
24 
25     public static void instanceofTest(Object p) {
26         if (p instanceof Animal)
27             System.out.println(p.getClass() + "類的實例  是類Animal的實例");
28         if (p instanceof Postgraduate)
29             System.out.println(p.getClass() + "類的實例  是類Postgraduate的實例");
30         if (p instanceof Student)
31             System.out.println(p.getClass() + "類的實例  是類Student的實例");
32         if (p instanceof Person1)
33             System.out.println(p.getClass() + "類的實例  是類Person的實例");
34         if (p instanceof Man)
35             System.out.println(p.getClass() + "類的實例  是接口Man的實例");
36         if (p instanceof Object)
37             System.out.println(p.getClass() + "類的實例  是類Object的實例");
38     }
39 }

 

上面的程序，展現各種之間的關係的繼承樹是：

 

 

上述程序中：

　　由上面繼承樹可知，某個類（接口也能夠當作一個特殊的類）的對象是否是其餘類（或接口）的實例，只需按箭頭方向，以此對象所在的類爲起點到達此繼承樹分支（可能有多個分支）終點，沿途通過的類（包括本類，或接口）就都是該對象的實例。

因此輸出結果是：

可是，要注意一點：

      在判斷某個類（接口也能夠當作一個特殊的類）的對象是否是其餘類（或接口）的實例，必定要首先進行向上轉型，而後纔可用instanceof關鍵字進行判斷，這是基本操做規範。

如：

 1 package instanceofTest;
 2 
 3 /**
 4  * @author zsh
 5  * @company wlgzs
 6  * @create 2019-03-21 20:02
 7  * @Describe
 8  */
 9 
10 interface A{
11     void say();
12 }
13 
14 class B implements A{
15     public void say()
16     {
17         System.out.println("B實現的say()方法");
18     }
19 }
20 
21 class C implements A{
22     public void say()
23     {
24         System.out.println("C實現的say()方法");
25     }
26 }
27 
28 public class Main2 {
29     public static void main(String[] args) {
30         A a= new B();  //接口不能new
31         System.out.println(a instanceof B);   //true;發生了A a= new B();
32         System.out.println(a instanceof C);   //false;沒有發生A a = new C();
33     }
34 }

運行結果：

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

在判斷接口A的對象a 是否是類C的實例時，沒有先進行向上轉型，就進行instanceof關鍵字的使用了，是確定會返回false的。

測試用例：

 1 package instanceofTest;
 2 
 3 /**
 4  * @author zsh
 5  * @company wlgzs
 6  * @create 2019-03-21 20:07
 7  * @Describe instanceof 測試用例
 8  */
 9 interface A{
10 
11 }
12 class B implements A{
13 
14 }
15 class C extends B{
16 
17 }
18 public class Main3 {
19     public static void main(String[] args) {
20         A ab=new B();
21         A ac=new C();
22         B bc=new C();
23         B bb=new B();
24         C cc=new C();
25         //對象實現一個接口，用這個對象和這個接口進行instanceof判斷，都爲true。
26         System.out.println("ab instanceof A="+(ab instanceof A));
27         System.out.println("ac instanceof A="+(ac instanceof A));
28         System.out.println("bc instanceof A="+(bc instanceof A));
29         System.out.println("bb instanceof A="+(bb instanceof A));
30         System.out.println("cc instanceof A="+(cc instanceof A));
31         //對象和父類進行instanceof判斷，都爲true
32         System.out.println("ab instanceof B="+(ab instanceof B));
33         System.out.println("ac instanceof B="+(ac instanceof B));
34         System.out.println("bc instanceof B="+(bc instanceof B));
35         System.out.println("bb instanceof B="+(bb instanceof B));
36         System.out.println("cc instanceof B="+(cc instanceof B));
37         //對象和他的子類進行instanceof判斷爲false
38         System.out.println("ab instanceof C="+(ab instanceof C));
39         System.out.println("ac instanceof C="+(ac instanceof C));
40         System.out.println("bc instanceof C="+(bc instanceof C));
41         System.out.println("bb instanceof C="+(bb instanceof C));
42         System.out.println("cc instanceof C="+(cc instanceof C));
43     }
44 }

運行結果：

總結：

若是一個類的實例是這個類自己的實例，那麼它也是它的父類、它的父類的父類的實例，也是由它實現的接口的實例
且instanceof左邊操做元顯式聲明的類型與右邊操做元必須是同種類或右邊是左邊父類的繼承關係 

此外：

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

//編譯不經過;'A'在此處視爲基本數據類型char，instanceof操做符只能用做對象的判斷
boolean b4 = 'A' instanceof Character;