1. /*
   
2. Object类 - equals()方法，示例
   
3. */
   
4. class Demo//extends Object
   
5. {
   
6.         private int num;
   
7.         Demo(int num)
   
8.         {
   
9.                 this.num = num;
   
10.         }
    
11.         public boolean equals(Object obj)//先是复写了Object的equals方法，再有多态Object obj = new Demo();
    
12.         {
    
13.                 Demo d = (Demo)obj;//强制类型转换（体现多态性）
    
14.                 return this.num == d.num;
    
15.         }
    
16. }
    
17. 
    
18. class Person
    
19. {
    
20.         Person(){}//可以不写，类创建时自动会默认一个隐式构造函数
    
21. }
    
22. 
    
23. class ObjectDemo
    
24. {
    
25.         public static void main(String[] args)
    
26.         {
    
27.                 Demo d1 = new Demo(3);
    
28.                 Demo d2 = new Demo(4);
    
29.                 Person p = new Person();
    
30.                 System.out.println(d1.equals(p));
    
31.                 /*
    
32.                 上面这一句，当书写d1.equals(p)时，编译可以通，过运行时会抛出“ClassCastException”，
    
33.                 因为通过equals()方法中Person类不可以被强制转换为Demo类。
    
34.                 上面这一句，而书写时很容易写成p.equals(d1)，这样却可以通过编译和运行，
    
35.                 我第一次敲时就误敲成了这，运行没有抛异常，感觉很诧异，想了下原来是equals()方法接收了d1,自然可以被类型转换。
    
36.                 求证我的理解是否正确？
    
37.                 */
    
38.                 System.out.println(d1.equals(d2));
    
39. 
    
40.         }
    
41. }

复制代码

求证这样理解是否正确？

这是因为你自定义的equals方法和object的不一样，而你自己定义一个新的类不去重写equals方法就会用object的equals方法。那是肯定能通过的，反之就不行.
public boolean equals(Object obj)//先是复写了Object的equals方法，再有多态Object obj = new Demo();
        {
                Demo d = (Demo)obj;//强制类型转换（体现多态性）在这里你把传进来的不管是什么对象直接就强转，肯定会报错，如果你加一个if判断就不会有了
                return this.num == d.num;
        }
楼主可以试试写成这样
public boolean equals(Object obj)//先是复写了Object的equals方法，再有多态Object obj = new Demo();
        {
                if(obj instanceof Demo )
                {
                    Demo d = (Demo)obj;//强制类型转换（体现多态性）
                     return this.num == d.num;
                }
              return false;
        }

p.equals(d1)
这句代码是使用Person的equals方法来接收d1的，因为这个Person没有重写Object的equals方法，所以这个equals的方法具体只是比较两个对象的引用是否相同而已，所以不会抛异常，也不会造成编译通不过。

你的理解是正确的。
因为equals(Object obj)
指示其他某个对象是否与此对象“相等”。所以即可以接受Demo类型，也可以接受Person类型。你的不同结果主要是
在第13行的代码13.                Demo d = (Demo)obj;//强制类型转换（体现多态性），下面详解

1：System.out.println(d1.equals(p));为什么这里通不过里，因为方法equals里面传的是p这个对象，p是属于Person类的一个对象，由于你上面代码是Demo d = (Demo)obj; 不可能将p这个对象强转成Demo类型。
public boolean equals(Object obj)//先是复写了Object的equals方法，再有多态Object obj = new Demo();

12.        {
                        if(!(p instanceof Test))//加上就可以通过
                         return false;
13.                Demo d = (Demo)obj;//强制类型转换（体现多态性）

14.                return this.num == d.num;

15.        }

2：System.out.println(p.equals(d1));就是你的理解equals()方法接收了d1,自然可以被类型转换。

上边的一部分我和楼主理解的一样，不过下边的就有些不明白了

1. 23.class ObjectDemo
   
2. 
   
3. 24.{
   
4. 
   
5. 25.        public static void main(String[] args)
   
6. 
   
7. 26.        {
   
8. 
   
9. 27.                Demo d1 = new Demo(3);
   
10. 
    
11. 28.                Demo d2 = new Demo(4);
    
12. 
    
13. 29.                Person p = new Person();
    
14. 
    
15. 30.                System.out.println(d1.equals(p));
    
16. 
    
17. 31.                /*
    
18. 
    
19. 32.                上面这一句，当书写d1.equals(p)时，编译可以通，过运行时会抛出“ClassCastException”，
    
20. 
    
21. 33.                因为通过equals()方法中Person类不可以被强制转换为Demo类。
    
22. 
    
23. 34.                上面这一句，而书写时很容易写成p.equals(d1)，这样却可以通过编译和运行，
    
24. 
    
25. 35.                我第一次敲时就误敲成了这，运行没有抛异常，感觉很诧异，想了下原来是equals()方法接收了d1,自然可以被类型转换。
    
26. 
    
27. 36.                求证我的理解是否正确？
    
28. 
    
29. 37.                */
    
30. 
    
31. 38.                System.out.println(d1.equals(d2));
    
32. 
    
33. 39.
    
34. 
    
35. 40.        }
    

复制代码

这里我就很不理解了，为什么demo可以被equals()接受，而person就不能呢？求详细

赵志勇 发表于 2012-7-1 19:32
上边的一部分我和楼主理解的一样，不过下边的就有些不明白了这里我就很不理解了，为什么demo可以被equals() ...

d1.equals(p);是Demo类中重写了Object类中的equals()方法  里面的代码Demo d = (Demo)obj;要求equals()方法接受得参数必须的Demo类型的
p.equals(d1)因为p类中没有重写Object里面的equals()方法,所以它调用的是父类Object里面的equals()方法,

赵志勇 发表于 2012-7-1 19:32
上边的一部分我和楼主理解的一样，不过下边的就有些不明白了这里我就很不理解了，为什么demo可以被equals() ...

d1.equals(p);是Demo类中重写了Object类中的equals()方法  里面的代码Demo d = (Demo)obj;要求equals()方法接受得参数必须的Demo类型的
p.equals(d1)因为p类中没有重写Object里面的equals()方法,所以它调用的是父类Object里面的equals()方法,

赵志勇 发表于 2012-7-1 19:32
上边的一部分我和楼主理解的一样，不过下边的就有些不明白了这里我就很不理解了，为什么demo可以被equals() ...

可以接收，只是若要接受Person类还缺乏相应语句。
Object类就是传说中的上帝嘛，Person类必然是它的子类。
若要接收，需在第12行加上一句：Person p = (Person)obj; 这样就强行转换了。