1. abstract class Animal
   
2. {
   
3.         abstract void eat();
   
4. }
   
5. class Cat extends Animal
   
6. {
   
7.         public void eat()
   
8.         {
   
9.            System.out.println("chiyu");
   
10.     }
    
11.         public void catchMouse()
    
12.         {
    
13.             System.out.println("抓老鼠");
    
14.     }
    
15. }
    
16. class Dog extends Animal
    
17. {
    
18.         public void eat()
    
19.         {
    
20.             System.out.println("kengutou");
    
21.         }
    
22.     public void kanJia()
    
23.         {
    
24.              System.out.println("看家");
    
25.         }
    
26. }
    
27. class Demo
    
28. {
    
29.      public static void main(String[] args)
    
30.       {
    
31.        function(new Cat());
    
32.            function(new Dog());
    
33.           }
    
34.       public static void function(Animal a)
    
35.       {
    
36.                  a.eat();
    
37.                <b>[b] if(a instanceof Cat)
    
38.                  {
    
39.                 Cat c =(Cat)a;
    
40.                 c.catchMouse();
    
41.                      }
    
42.                      else if(a instanceof Dog)
    
43.                      {
    
44.                       Dog c =(Dog)a;
    
45.                   c.kanJia();[/b]</b>
    
46.                      }
    
47.           }
    
48.    }
    
49. 
    
50. 上面加粗部分代码是什么意思？哪位仁兄帮忙解读一下
    
51. 还有  ’instanceof‘    ’equals‘    ’ == ‘这三者分别怎么用！何时用？
    
52. 
    
53. 
    
54. 
    
55. 
    
56. 
    

复制代码

java 中的instanceof 运算符是用来在运行时指出对象是否是特定类的一个实例。instanceof通过返回一个布尔值来指出，这个对象是否是这个特定类或者是它的子类的一个实例。
==其实是比较两个对象的内存地址
而equals方法是比较两个对象是否内容相等，可以覆盖自己定义规则

a instanceof b如果a 属于b类型的对象， 运算结果就是true== 在基本数据类型时，比较的是数值是否一致，在引用数据类型中，比较的是对象的真实内存地址是否一致。
equals方法，默认(不覆盖父类的)比较的对象的真实内存地址
覆盖equals的方法，建立对象自己的比较方式，比较的是类中成员变量的具体数值

     java 中的instanceof 运算符是用来在运行时指出对象是否是特定类的一个实例。instanceof通过返回一个布尔值来指出，这个对象是否是这个特定类或者是它的子类的一个实例。    java中的==用来判断两个变量是否相等或变量是否等于常量。
    Java中equals（）是一种Object类中的方法，用来判断两个对象的地址是否相同。但是用户也可以自己定义equals方法的内容。

这些都是很基础的例子而已，
只要看下视频，做下例子都能理解的，
而且论坛也有人提问过了可以搜索。

1.上面的程序，加粗的部分，涉及多态的知识。
定义一个方法 function(Animal a) ，将new出来的猫猫狗狗对象作为形参传给它，
然后它就通过instanceof判断你传入的究竟是猫还是狗？
是猫就输出 猫吃什么，猫做什么；否则狗就吃什么，猫做什么。

2. "instanceof" "equals" "==" 这三者分别怎么用！何时用？

首先，"instanceof"就是对象是否属于某个类型的时候用的，
返回boolean类型的数据。可以用在继承中的子类的实例是否为父类的实现。

1. String s = "I am an Object.";
   
2. boolean isobject = s instanceof Object;

复制代码

而equals和"=="，可以简单这样理解：

equals和==都是比较对象，但equals就是比较对象的内容，而==还会比较对象的地址。

1. class Demo {
   
2.         public static void main(String[] args) {
   
3.                 String s1 = new String("abc");
   
4.                 String s2 = new String("abc");
   
5.                 String s3 = new String("def");
   
6.                 System.out.println(s1.equals(s2)); // 这个结果是true
   
7.                 System.out.println(s1.equals(s3));// 这个结果是false
   
8.                 System.out.println(s1 == s2); // 这个结果是false
   
9.                 System.out.println(s1 == s3);// 这个结果是false
   
10.         }
    
11. }
    

复制代码

"=="运算符专门用来比较两个变量的值是否相等，也就是比较两个变量缩所对应的内存中所存储的值是否相等。要比较两个基本数据类型的数据或者两个引用变量是否相等。只能用"=="；
如果一个变量指向的数据类型是对象类型的，那么这就涉及到两个内存，对象本身一块内存（堆内存），变量一块内存（栈内存），例如Object obj = new Object();变量obj对应一块内存，new Object()占一块内存，此时obj对应内存中所存储的数据就是对象所占内存的首地址。  对于指向对象的变量，如果要比较两个变量是否指向同一个对象。即比较两个变量对应内存中所存储的数值是否相等。这时就要用"=="。
equals方法是比较两个独立对象的内容是否相同，例如下面代码:
String a = new String("qingmulang");
String b = new String("qingmulang");
两条new语句创建了两个对象，a，b两个变量分别指向其中一个对象。这是两个不同的对象，他们的首地址是不同的，即a和b所存储的数值是不相同的。所以：
reurn a==b;------>false;
return a.equals(b)---->true;
  如果一个类没有自己定义一个equals方法，那么默认的equa方式是从Object继承来的就是"=="操作费，也就是比较两个变量是否指向同一个对象，这时候equals和"=="结果是相同的，如果比较两个独立对象结果总是返回false。
Objec类中equals方法如下
boolean equals(Object o)
{
    return this == o;
}
instanceof是用来检查一个对象是否是一个类的实例
希望对各位有帮助

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