就是在代码中遇到一个问题, instanceof     与 equals  或 ==   的区别

请指点....

quals比较两个对象的地址值，毫无意义
  |-- 子类应该覆盖equals方法，建立子类自己独特比较方式
  |-- == 和equals方法
       == 在基本数据类型中，比较的是变量的实际值
       == 在引用数据类型中，比较的是引用类型的地址值
       equals方法，比较的也是引用类型的地址值
       equals方法，可以自定义对象的比较方式

equals 根据具体类中的equals方法来来比较两个对象
==  引用数据类型 比较两个引用类型的地址值   基本数据类型比较两个数据的值

instanceof 是判断 一个实例化对象是否属于一个类

equals方法和instanceof 的区别：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”。

（1）对于字符串变量来说，使用“==”和“equals()”方法比较字符串时，其比较方法不同。
“==”比较两个变量本身的值，即两个对象在内存中的首地址。
“equals()”比较字符串中所包含的内容是否相同。
比如：
String s1,s2,s3 = "abc", s4 ="abc" ;
s1 = new String("abc");
s2 = new String("abc");
那么：
s1==s2   是 false      //两个变量的内存地址不一样，也就是说它们指向的对象不 一样，

故不相等。


s1.equals(s2) 是 true    //两个变量的所包含的内容是abc，故相等。

注意（1）：
如果：        StringBuffer s1 = new StringBuffer("a");
                StringBuffer s2 = new StringBuffer("a");
                     
结果：      s1.equals(s2)  //是false
解释：StringBuffer类中没有重新定义equals这个方法，因此这个方法就来自Object类， 而Object类中的equals方法是用来比较“地址”的，所以等于false.
注意（2）：
对于s3和s4来说，有一点不一样要引起注意，由于s3和s4是两个字符
串常量所生成的变量，其中所存放的内存地址是相等的，
所以s3==s4是true（即使没有s3=s4这样一个赋值语句）

（2）对于非字符串变量来说，"=="和"equals"方法的作用是相同的都是用来比较其
对象在堆内存的首地址，即用来比较两个引用变量是否指向同一个对象。
比如：
class A
{
      A obj1   =   new  A();
      A obj2   =   new  A();
}
那么：obj1==obj2是false
            obj1.equals(obj2)是false

但是如加上这样一句：obj1=obj2;
那么  obj1==obj2  是true
          obj1.equals(obj2) 是true

总之：equals方法对于字符串来说是比较内容的，而对于非字符串来说是比较
其指向的对象是否相同的。
             == 比较符也是比较指向的对象是否相同的也就是对象在对内存中的的首地址。
  

String类中重新定义了equals这个方法，而且比较的是值，而不是地址。所以是true。

你参考这个帖子一下
http://bbs.itheima.com/thread-41940-1-1.html

instanceof的用法：对象 instanceof 类名

Animal:
        eat
Dog:
        eat,play
Cat:
        eat,play

Animal a = new Dog();
printAnimal(a);
a = new Cat();
printAnimal(a);


printAnimal(Animal a)
{
        if(a instanceof Dog)
        {
                Dog d = (Dog)a;
                d.eat();
                d.play();
        }
        else if(a instanceof Cat)
        {
                Cat c = (Cat)a;
                c.eat();
                c.play();
        }
}
==操作符专门用来比较两个变量的值是否相等，也就是用于比较变量所对应的内存中所存储的数值是否相同，要比较两个基本类型的数据或两个引用变量是否相等，只能用==操作符。
如果一个变量指向的数据是对象类型的，那么，这时候涉及了两块内存，对象本身占用一块内存（堆内存），变量也占用一块内存，例如Objet obj = new Object();变量obj是一个内存，new Object()是另一个内存，此时，变量obj所对应的内存中存储的数值就是对象占用的那块内存的首地址。对于指向对象类型的变量，如果要比较两个变量是否指向同一个对象，即要看这两个变量所对应的内存中的数值是否相等，这时候就需要用==操作符进行比较。
equals方法是用于比较两个独立对象的内容是否相同，就好比去比较两个人的长相是否相同，它比较的两个对象是独立的。例如，对于下面的代码：
String a=new String("foo");
String b=new String("foo");
两条new语句创建了两个对象，然后用a,b这两个变量分别指向了其中一个对象，这是两个不同的对象，它们的首地址是不同的，即a和b中存储的数值是不相同的，所以，表达式a==b将返回false，而这两个对象中的内容是相同的，所以，表达式a.equals(b)将返回true。
在实际开发中，我们经常要比较传递进行来的字符串内容是否等，例如，String input = …;input.equals(“quit”)，许多人稍不注意就使用==进行比较了，这是错误的，随便从网上找几个项目实战的教学视频看看，里面就有大量这样的错误。记住，字符串的比较基本上都是使用equals方法。
如果一个类没有自己定义equals方法，那么它将继承Object类的equals方法，Object类的equals方法的实现代码如下：
boolean equals(Object o){
return this==o;
}
这说明，如果一个类没有自己定义equals方法，它默认的equals方法（从Object 类继承的）就是使用==操作符，也是在比较两个变量指向的对象是否是同一对象，这时候使用equals和使用==会得到同样的结果，如果比较的是两个独立的对象则总返回false。如果你编写的类希望能够比较该类创建的两个实例对象的内容是否相同，那么你必须覆盖equals方法，由你自己写代码来决定在什么情况即可认为两个对象的内容是相同的。

一、“instanceof”  和  “==” 的区别
instanceof : 用于判断对象的类型。 格式：对象 intanceof 类型(类类型  接口类型) 。instanceof操作符用于判断一个引用类型所引用的对象是否是一个类的实例 ；对于引用类型变量，Java 编译器只根据变量被先声明的类去编译。 instanceof 左边操作元被显式声明的类型与右边操作元必须是同种类或者有继承关系，即位于继承树的同一个继承分支上，否则编译出错。
“==”运算符：用来判断2个变量是否相等。
示例代码：

1. abstract class Animal
   
2. {
   
3.         abstract void eat();
   
4. 
   
5. }
   
6. 
   
7. class Cat extends Animal
   
8. {
   
9.         public void eat()
   
10.         {
    
11.                 System.out.println("吃鱼");
    
12.         }
    
13.         public void catchMouse()
    
14.         {
    
15.                 System.out.println("抓老鼠");
    
16.         }
    
17. }
    
18. 
    
19. class Dog extends Animal
    
20. {
    
21.         public void eat()
    
22.         {
    
23.                 System.out.println("吃骨头");
    
24.         }
    
25.         public void kanJia()
    
26.         {
    
27.                 System.out.println("看家");
    
28.         }
    
29. }
    
30. 
    
31. 
    
32. class DuoTaiDemo1
    
33. {
    
34.         public static void main(String[] args)
    
35.         {
    
36.                 function(new Dog());
    
37.                 function(new Cat());
    
38.         }
    
39.         public static void function(Animal a)       //Animal a = new Cat();
    
40.         {
    
41.                 a.eat();
    
42. 
    
43.                 if(a instanceof Cat)   //这里是if语句的条件判断，与变量判断if(x==y)同理,判断a所引用的对象是否是类Cat的实例      
    
44.                 {
    
45.                         Cat c = (Cat)a;
    
46.                         c.catchMouse();
    
47.                 }
    
48.                 else if(a instanceof Dog)
    
49.                 {
    
50.                         Dog c = (Dog)a;
    
51.                         c.kanJia();
    
52.                 }
    
53.         }
    
54. }

复制代码

二、“==”和“equals()” 的区别

（一）对于字符串变量来说，使用“==”和“equals()”方法比较字符串时，其比较方法不同。

“==”比较两个变量本身的值，即两个对象在内存中的首地址。

“equals()”比较字符串中所包含的内容是否相同。

比如：

1. String s1,s2,s3 = "abc", s4 ="abc" ;
   
2. s1 = new String("abc");
   
3. s2 = new String("abc");

复制代码

那么：

s1==s2   是 false      //两个变量的内存地址不一样，也就是说它们指向的对象不 一样，故不相等。

s1.equals(s2) 是 true    //两个变量的所包含的内容是abc，故相等。

注意（1）：

    如果：        StringBuffer s1 = new StringBuffer("a");
                      StringBuffer s2 = new StringBuffer("a");
                     

    结果：      s1.equals(s2)  //是false

    解释：StringBuffer类中没有重新定义equals这个方法，因此这个方法就来自Object类，而Object类中的equals方法是用来比较“地址”的，所以等于false.

注意（2）：

    对于s3和s4来说，有一点不一样要引起注意，由于s3和s4是两个字符串常量所生成的变量，其中所存放的内存地址是相等的，所以s3==s4是true（即     使没有s3=s4这样一个赋值语句）。

（二）对于非字符串变量来说，"=="和"equals"方法的作用是相同的，都是用来比较其对象在堆内存的首地址，即用来比较两个引用变量是否指向同一个           对象。

比如：

1. class A
   
2. {
   
3.       A obj1   =   new  A();
   
4.       A obj2   =   new  A();
   
5. }

复制代码

        那么：obj1==obj2是false

                  obj1.equals( obj2 )是false

但是如果加上这样一句：obj1=obj2;

        那么：obj1==obj2  是true

                  obj1.equals(obj2) 是true

总之：equals方法对于字符串来说是比较内容的；而对于非字符串来说是比较其指向的对象是否相同的，也就是对象在对内存中的的首地址。

          == 比较符对于字符串和非字符串是一样的，都是比较指向的对象是否相同的，也就是对象在对内存中的的首地址。

三、equals方法和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()方法，自己定义比较规则

• 对称性：如果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”。

1）对于字符串变量来说，使用“==”和“equals()”方法比较字符串时，其比较方法不同。

“==”比较两个变量本身的值，即两个对象在内存中的首地址。

“equals()”比较字符串中所包含的内容是否相同。

比如：

String s1,s2,s3 = "abc", s4 ="abc" ;

s1 = new String("abc");

s2 = new String("abc");

那么：

s1==s2   是 false      //两个变量的内存地址不一样，也就是说它们指向的对象不 一样，

故不相等。



s1.equals(s2) 是 true    //两个变量的所包含的内容是abc，故相等。



注意（1）：

如果：        StringBuffer s1 = new StringBuffer("a");
                 StringBuffer s2 = new StringBuffer("a");
                       

结果：      s1.equals(s2)  //是false

解释：StringBuffer类中没有重新定义equals这个方法，因此这个方法就来自Object类， 而Object类中的equals方法是用来比较“地址”的，所以等于false.

注意（2）：

对于s3和s4来说，有一点不一样要引起注意，由于s3和s4是两个字符

串常量所生成的变量，其中所存放的内存地址是相等的，

所以s3==s4是true（即使没有s3=s4这样一个赋值语句）


（2）对于非字符串变量来说，"=="和"equals"方法的作用是相同的都是用来比较其

对象在堆内存的首地址，即用来比较两个引用变量是否指向同一个对象。

比如：

class A

{

      A obj1   =   new  A();

      A obj2   =   new  A();

}

那么：obj1==obj2是false

            obj1.equals(obj2)是false



但是如加上这样一句：obj1=obj2;

那么  obj1==obj2  是true

          obj1.equals(obj2) 是true



总之：equals方法对于字符串来说是比较内容的，而对于非字符串来说是比较

其指向的对象是否相同的。

             == 比较符也是比较指向的对象是否相同的也就是对象在对内存中的的首地址。

  



String类中重新定义了equals这个方法，而且比较的是值，而不是地址。所以是true。



顺便总结下equals方法和instanceof 的区别：

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”。