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，大概是用来判断是不是同一个人的吧