1. public class Student {
   
2.         private String name;
   
3.           private int age;
   
4.           public Student(String name,int age)
   
5.           {
   
6.           this.name=name;
   
7.           this.age=age;
   
8.           }
   
9.           public static void main(String[] args)
   
10.           {
    
11.           Student st1 = new Student("zhang",20);
    
12.           Student st2 = new Student("zhang",20);
    
13.           if(st1.equals(st2))
    
14.                           System.out.print("相等");
    
15.           else
    
16.                         System.out.print("不相等");
    
17. 
    
18.         }
    
19. 
    
20. }

复制代码

为什么输出不相等?

在超类Object中定义的equals(Object obj)方法，实现对于任何非空引用值 x 和 y，当且仅当 x 和 y 引用同一个对象时，此方法才返回 true。即st1和st2指向的是同一个对象，才返回true.在你的代码中，创建了两个对象，在对内存中就就产生了两个对象。st1里面装的是第一对象的内存地址值，st2里面装的是第二个对象的内存地址值。折射到现实生活中，意思就是两个同名同年龄的人，而不是同一个人。两个不同的人，当然不相等啊。

老问题，没有复写equals（）方法：

1. public class Student {
   
2.     private String name;
   
3.       private int age;
   
4.       public Student(String name,int age)
   
5.       {
   
6.       this.name=name;
   
7.       this.age=age;
   
8.       }
   
9.       public static void main(String[] args)
   
10.       {
    
11.       Student st1 = new Student("zhang",20);
    
12.       Student st2 = new Student("zhang",20);
    
13.       if(st1.equals(st2))
    
14.                       System.out.print("相等");
    
15.       else
    
16.                     System.out.print("不相等");
    
17. 
    
18.     }
    
19.      public boolean equals(Object obj){
    
20.               
    
21.               
    
22.               
    
23.               if(obj==null) return false;
    
24.               else
    
25.               {
    
26.                if(obj instanceof Student){
    
27.                 Student c=(Student)obj;//强制转换
    
28.                if(c.name==this.name && c.age==this.age ){
    
29.                 return true;
    
30.                }
    
31.                }
    
32.               }
    
33.               return false;
    
34.               
    
35.              }
    
36.             
    
37. 
    
38. 
    
39. }

复制代码

有意思！你是两个对象进行比较，你可以分别打出来这两个对象的值！他们是不一样的，两个内存地址。只有字符串的比较用equals。

equals是指示其他某个对象是否与此对象相等。
Student st1 = new Student("zhang",20);
Student st2 = new Student("zhang",20)
st1和st2分别new了student 。 也就是说在堆内存中有两个student他们没别属于st1和st2，有两个地址值
这里的equals就是在比较st1、 st2在堆内存中的地址值。当然就不相等了

任何类都有一个超类object,该类具有判断两对象是否相等方法equals()，规则是，如果两对象通过==判定后相等就相等，而==比较两对象的地址，如果需要更改比较规则，需要重写equals();

String str1 = "abc";
String str2 = "abc";
System.out.println(str1==str2); //true
可以看出str1和str2是指向同一个对象的。

String str1 =new String ("abc");
String str2 =new String ("abc");
System.out.println(str1==str2); // false
用new的方式是生成不同的对象。每一次生成一个。
        因此用第二种方式创建多个”abc”字符串,在内存中其实只存在一个对象而已. 这种写法有利与节省内存空间. 同时它可以在一定程度上提高程序的运行速度，因为JVM会自动根据栈中数据的实际情况来决定是否有必要创建新对象。而对于String str = new String("abc")；的代码，则一概在堆中创建新对象，而不管其字符串值是否相等，是否有必要创建新对象，从而加重了程序的负担。