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，大概是用來判斷是不是同一個人的吧