1. class MyDate{
   
2.         int day,month,year;
   
3.         public MyDate(int i,int j,int k){
   
4.                 day = i;
   
5.                 month = j;
   
6.                 year = k;}
   
7.         }
   
8.         
   
9.         class MyOkDate extends MyDate{
   
10.                 public MyOkDate(int i, int j, int k){
    
11.                         super (i,j,k);
    
12.         }
    
13.         public boolean equals(Object obj){
    
14.                 if (obj instanceof MyOkDate){MyOkDate m = (MyOkDate)obj;
    
15.                 if (m.day==day && m.month==month && m.year==year)
    
16.                 return true;
    
17.         }
    
18.         return false;
    
19. }
    
20. }
    
21. 
    
22. public class TestEqualsObject{
    
23.         public static void main(String[] args){
    
24.                 MyDate m1 = new MyDate(24,3,2001);
    
25.                 MyDate m2 = new MyDate(24,3,2001);
    
26.                 System.out.println(m1.equals(m2));
    
27.                 m1 = new MyOkDate(24,3,2001);
    
28.                 m2 = new MyOkDate(24,3,2001);
    
29.                 System.out.println(m1.equals(m2));
    
30.         }
    
31. }

复制代码

结果是：false
true   
我不明白第一个为什么是false啊，各位指教指教啊

第一个为false，因为m1.equals(m2)时，实际比较的是m1和m2引用地址。

1. public boolean equals(Object obj) {
   
2.         return (this == obj);
   
3.     }

复制代码

你没有覆盖equals方法时，调用的是Object类中的equals方法，而m1和m2是不同的对象，所以是false。
第二个为true是因为你覆盖了Object的equals方法，所以调用时比较的就是对象的内容，而不是引用的地址。

这里你应该注意 equals 和 == 的区别
== ，用于数值比较，比较的是两个字符串的空间地址值
equals，用于内容的比较，比较两个字符串的内容是否相等

MyDate m1 = new MyDate(24,3,2001);
MyDate m2 = new MyDate(24,3,2001);
因为你new了两个对象，此时，堆内存分别出现了相对应的两个空间地址值，
所以你在这一步public boolean equals(Object obj)判断时，直接两个不同的空间地址值的比较，所以会返回false。

第一个equals返回false是因为你new了两个MyDate对象，调用了Object中的equals进行了比较不是一个对象返回值都为false;
而第二个返回值为true ，是因为你调用了子类内部的的重写了Object的equals方法，进行比较，所以返回值为true;

MyDate没有覆盖equals（）方法，所以比较是是引用故不相等。false
public boolean equals(Object obj){
                if (obj instanceof MyOkDate){MyOkDate m = (MyOkDate)obj;
                if (m.day==day && m.month==month && m.year==year)
                return true;
比较的是值是否相等所以是true

我把你的代码修改了一下，把equals方法放到父类里，这样子类继承的就是父类的equals方法，覆盖了Object类中的equals方法。

1. <blockquote>class MyDate

复制代码

上一个代码没有显示出来

1. class MyDate
   
2. {
   
3.         int day,month,year;
   
4.         public MyDate(int i,int j,int k)
   
5.                 {
   
6.                 day = i;
   
7.                 month = j;
   
8.                 year = k;
   
9.                 }
   
10.                 public boolean equals(Object obj)
    
11.                 {
    
12.                 if (obj instanceof MyOkDate||obj instanceof MyDate)
    
13.                                 {       
    
14.                                         //多态，如果obj是MyDate，也可以强转成其父类，类型提升。
    
15.                                         MyDate m = (MyDate)obj;
    
16.                                         if (m.day==day && m.month==month && m.year==year)
    
17.                                         return true;
    
18.                                 }
    
19.                                 return false;
    
20.                 }
    
21. }
    
22. class MyOkDate extends MyDate
    
23. {
    
24.                 public MyOkDate(int i, int j, int k)
    
25.                 {
    
26.                         super (i,j,k);
    
27.                 }
    
28. }
    
29. 
    
30. public class Test2
    
31. {
    
32.         public static void main(String[] args)
    
33.                 {
    
34.                 MyDate m1 = new MyDate(24,3,2001);
    
35.                 MyDate m2 = new MyDate(24,3,2001);
    
36.                 System.out.println(m1.equals(m2));
    
37.                 m1 = new MyOkDate(24,3,2001);
    
38.                 m2 = new MyOkDate(24,3,2001);
    
39.                 System.out.println(m1.equals(m2));
    
40.         }
    
41. }

复制代码