在查询信息时，以instanceof的形式与直接比较Class对象有什么差别

instanceof操作符用于判断一个引用类型所引用的对象是否是一个类的实例
对于引用类型变量，Java 编译器只根据变量被先生声明的类去编译。
   instanceof 左边操作元被显式声明的类型与右边操作元必须是同种类或者有继承关系，即位于继承树的同一个继承分支上，否则编译出错
Object 类的 equals() 方法的比较规则为：当参数 obj 引用的对象与当前对象为同一个对象时，就返回true，否则返回false
在JDK中有一些类覆盖了 Object 类的equals()方法，它们的比较规则为：
  如果两个对象的类型一致，并且内容一致，则返回true。
这些类包括：java.io.File、java.util.Date、java.lang.String、包装类(如java.lang.Integer和java.lang.Double类)。
如果是自己定义的类的话，可以复写equals()方法，自己定义比较规则

Java语言对equals()的要求如下，这些要求是必须遵循的，以下几点也算是和instance of 的区别：
• 对称性：如果x.equals(y)返回是“true”，那么y.equals(x)也应该返回是“true”。
• 反射性：x.equals(x)必须返回是“true”。
• 类推性：如果x.equals(y)返回是“true”，而且y.equals(z)返回是“true”，那么z.equals(x)也应该返回是“true”。
• 还有一致性：如果x.equals(y)返回是“true”，只要x和y内容一直不变，不管你重复x.equals(y)多少次，返回都是“true”。
• 任何情况下，x.equals(null)，永远返回是“false”；x.equals(和x不同类型的对象)永远返回是“false”。

这里对比下instance of和equals的区别:
instanceof 看一个对象（或称为引用）是否与某类兼容。兼容的有其自身所属的类、所有的父类、实现的所有接口及这些接口的父接口。这样返回为true
Java语言对equals()的要求如下，这些要求是必须遵循的(也是两者的主要区别)：  
对称性：如果x.equals(y)返回是“true”，那么y.equals(x)也应该返回是“true”。 对于instance of就不一定了： 如果a是b的子类对象 a instanceof b 为true ,但 b instanceof a就是false了,关于下面几点可以自己推敲下.   
反射性：x.equals(x)必须返回是“true”。
类推性：如果x.equals(y)返回是“true”，而且y.equals(z)返回是“true”，那么z.equals(x)也应该返回是“true”。
还有一致性：如果x.equals(y)返回是“true”，只要x和y内容一直不变，不管你重复x.equals(y)多少次，返回都是“true”。
任何情况下，x.equals(null)，永远返回是“false”；x.equals(和x不同类型的对象)永远返回是“false”。
String 、Math、还有Integer、Double。。。。等这些封装类在使用equals()方法时，已经覆盖了object类的equals（）方法。是进行的内容比较，而已经不再是地址的比较。

1. package LianXi;
   
2. public class TestDemo
   
3. {
   
4.         public static void main(String[] args)
   
5.         {
   
6. 
   
7.                 A objA = new A();
   
8.                 A objA2 = new A();
   
9.                 Class  classA = objA.getClass();
   
10.                 B objB = new B();
    
11.                 Class classB = objB.getClass();
    
12. 
    
13.                 if( objB instanceof A)
    
14.                          print("objA 是 A 类型");
    
15. 
    
16.                 if(classA == objA2.getClass())
    
17.                         print("证明相同类型的class实例是单例模式");
    
18. 
    
19.                 if(classA == classB)
    
20.                         print("objA 与 objB是同一个类型的变量");
    
21.                 else
    
22.                         print("不同类型的实例的class实例是不同的");
    
23.                 if(     objB instanceof Object &&
    
24.                                 objB instanceof AbBase &&
    
25.                                 objB instanceof Base&&
    
26.                                 objB instanceof A &&
    
27.                                 objB instanceof B &&
    
28.                                 objB instanceof I )
    
29.                         print("只要类型T 在某个对象继承链上 instanceof T 都会返回 true");
    
30.        
    
31.                        
    
32.         }
    
33. 
    
34.         public static void print(Object o){
    
35.                 System.out.println(o);
    
36.         }
    
37. }
    
38. 
    
39. abstract  class AbBase
    
40. {
    
41. }
    
42. class Base extends AbBase
    
43. {
    
44. }
    
45. 
    
46. class A extends Base
    
47. {
    
48. }
    
49. 
    
50. class B extends A
    
51.                         implements I
    
52. {
    
53. }
    
54. 
    
55. class C implements I
    
56. {
    
57. }
    
58. 
    
59. interface I
    
60. {
    
61. }

复制代码

不知道 下面的代码能不能说明白。我想应该是比较清楚的了

哦了，差不多明白了