javaequals重寫
1. 如何重寫java中的equals方法
publicclassTest{
privateLongid;
publicLonggetId(){
returnid;
}
publicvoidsetId(Longid){
this.id=id;
}
publicbooleanequals(Testt){
returnthis.getId().compareTo(t.getId())==0;
}
publicstaticvoidmain(String[]args){
Testt1=newTest();
Testt2=newTest();
t1.setId(1L);
t2.setId(1L);
System.out.println(t1.equals(t2));
}
}
其實重寫equals 就是為了讓某個類符合自己的equal標准。 比如上面的例子, 重寫了Test的equals方法(equals方法是Object的,所以所有的類都有equals方法。)我們的標準是 一旦兩個test 的id相同 那麼我們就認為他們equal。 如果把重寫的equals方法注釋掉, 再運行 會列印false, 因為會調用super的equals方法, super的方法體是 obj1 == obj2 跟id沒有關系。
2. Java中關於==和equal的區別 以及equals方法重寫
//==與equals的默認行為都是比較引用是否相等,即是否引用了同一個對象。
//且==的行為是固定的,它總是比較引用,
//而equals的行為可以在子類中由用戶重寫。
//沒有equal方法。下面是例子。
public class EQ
{
public static void main(String[] args)
{
//s11,s12引用了兩個不同的對象,這兩個對象的所有欄位的值都相等
Student1 s11=new Student1("lili",'女',19);
Student1 s12=new Student1("lili",'女',19);
//s11,s13引用了一個相同的對象
Student1 s13=s11;
//這個if...else輸出s11!=s12,因為==默認是比較引用,
//而s11與s12引用的是兩個不同的對象
if(s11==s12)
{
System.out.println("s11==s12");
}
else
{
System.out.println("s11!=s12");
}
//這個if...else輸出not s11.equals(s12),
if(s11.equals(s12))
{
System.out.println("s11.equals(s12)");
}
else
{
System.out.println("not s11.equals(s12)");
}
//這個if...else輸出s11==s13,
//因為s11與s13引用的是同一個對象
if(s11==s13)
{
System.out.println("s11==s13");
}
else
{
System.out.println("s11!=s13");
}
//這個if...else輸出s11.equals(s13)
if(s11.equals(s13))
{
System.out.println("s11.equals(s13)");
}
else
{
System.out.println("not s11.equals(s13)");
}
//s21,s22引用了兩個不同的對象,這兩個對象只有age欄位的值相等
Student2 s21=new Student2("lili",'女',19);
Student2 s22=new Student2("張三",'男',19);
//這個if...else輸出s11!=s12,因為==總是比較引用
if(s21==s22)
{
System.out.println("s21==s22");
}
else
{
System.out.println("s21!=s22");
}
//這個if...else輸出s21.equals(s22),因為調用的是子類Student2的重寫的equals方法
if(s21.equals(s22))
{
System.out.println("s21.equals(s22)");
}
else
{
System.out.println("not s21.equals(s22)");
}
}
}
class Student1
{
Student1(String n,char s,int a)
{
this.name=n;
this.sex=s;
this.age=a;
}
String name;
char sex;
int age;
}
//重寫了繼承自類Object的equals和hashCode方法
class Student2
{
Student2(String n,char s,int a)
{
this.name=n;
this.sex=s;
this.age=a;
}
//重寫equals,如果兩個Student2對象的age值相等,則它們相等
//重寫此方法時,通常也必須重寫hashCode方法,以維護hashCode方法的常規協定,
//該協定聲明相等對象必須具有相等的哈希碼。
public boolean equals(Object obj)
{
boolean r=false;
System.out.println("Student2.equals被調用!");
if(null!=obj && obj instanceof Student2)
{
r=(this.age==((Student2)obj).age);
}
return r;
}
//重寫hashCode
public int hashCode()
{
return age;
}
String name;
char sex;
int age;
}
3. 如何重寫Java中的equals方法
//在你的類A中定義一個簽名為
//@Override
//public boolean equals(Object obj)的方法就能重寫(覆蓋)Object類的同名方法了,
//以後調用equals方法比較兩個類A的對象的相等性時,就會調用你重寫的方法了。
//看例子。
public class Demo
{
public static void main(String[] args)
{
A a1=new A(1,'a'),a2=new A(1,'b'),a3=new A(1,'a');
//調用類A的重寫的equals方法比較3個對象的相等性
//false
System.out.println(""+a1.equals(a2));
//true
System.out.println(""+a1.equals(a3));
//false
System.out.println(""+a2.equals(a3));
}
}
class A
{
A(int n,char c)
{
this.n=n;
this.c=c;
}
//@Override可省略
@Override
public boolean equals(Object obj)
{
System.out.println("調用了重寫的類A的equals方法。");
boolean r=false;
A a;
if(obj instanceof A)
{
a=(A)obj;
r=(this.n==a.n && this.c==a.c);
}
return r;
}
private int n;
private char c;
}
4. java equals方法的重寫
我幫你重寫一下你這個類裡面的equals方法吧 ,以後都可以根據情況套用:
public boolean equals(Object obj) {
if(obj==null)
return false;
if(this == obj){
return true;
}
if (obj instanceof Person) {
Person other = (Person) obj;
return (p.name).equals(this.name);
}
return false;
}
5. java定義類里重寫equals方法的問題
this代表的是Person類,當前類的對象;父類引用指向子類對象是不能訪問子類里的獨有成員這個沒有錯。
o是形參,轉之前先進行了判斷,符合條件後才強轉轉成Person類,然後進行比較
下面的是標准寫法,供你參考
通常自己的類裡面這樣重寫equals方法,如果重寫equals,則必須重寫hashcode方法
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Share other = (Share) obj; // 換成你自己的類
if (cn_share_id == null) {
if (other.cn_share_id != null) // 要比較的成員
return false;
} else if (!cn_share_id.equals(other.cn_share_id))
return false;
return true;
}
6. java為什麼要重寫equals !
重寫並不是說object類裡面的equals方法有缺陷,而是為了不同場景的需要。不同對象相同的方法不一樣。
比如說對象是人,它有2個屬性,name和height。有AB兩個人,我們怎麼來判斷這兩個人是同一個人還是不同的人,這里就要用到比較 , A.equals(B);
這里的equals就需要重新object類里的方法,來告訴程序,怎麼判斷2個人是同一個人
1。名字相同他們就是同一個人
2。name 和height 相同才是一個人
所以需要重新,例子簡單不曉得你看明白沒。
7. Java 創建簡單Java 類 有參無參 重寫equals方法
packagecom.sxl.test;
publicclassPerson{
//屬性:姓名、性別、年齡
privateStringname;
privateStringsex;
privateintage;
//無參構造
publicPerson(){
super();
}
//帶參構造
publicPerson(Stringname,Stringsex,intage){
super();
this.name=name;
this.sex=sex;
this.age=age;
}
//重寫equals方法
@Override
publicbooleanequals(Objectarg0){
if(arg0==Person.class){
returntrue;
}
returnfalse;
}
}
8. 新人求助,關於JAVA的equals方法的重寫問題
1.引用類型的基類沒有重寫Equals
2.引用類型的基類重寫了Equals
3.值類型重寫了Equals
if (this == obj)
return true; //對象類型是否相同,不同返回false
if (obj == null)
return false; //對象是否為空,為空返回false
if (!(obj instanceof Person))
return false; //對象不是Person類型
Person other = (Person) obj; //定義一個Person對象
if (age != other.age)
return false; //age是否等於other.age
if (name == null) { //姓名為空,,,,,下面的不解釋了,自己應該看得懂了
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
這段代碼重寫equals方法的原因,應該是person對象只有在姓名和年齡都相同時,才返回true,大概是用來判斷是不是同一個人的吧