java重写equals

❶ 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;
}

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

❸ 如何重写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;
}

❹ 如何重写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没有关系。

❺ 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;
}

❻ java为什么要重写equals ！

重写并不是说object类里面的equals方法有缺陷，而是为了不同场景的需要。不同对象相同的方法不一样。
比如说对象是人，它有2个属性，name和height。有AB两个人，我们怎么来判断这两个人是同一个人还是不同的人，这里就要用到比较 , A.equals(B);
这里的equals就需要重新object类里的方法，来告诉程序，怎么判断2个人是同一个人
1。名字相同他们就是同一个人
2。name 和height 相同才是一个人
所以需要重新，例子简单不晓得你看明白没。

❼ 在 com . tjl .demo18/ Student . java 类中为什么重写equals

equals方法继承自Object类，Object的equals方法是通过判断地址是否相同来判断是否同一对象，也就是是否相等。
在Student类中重写equals方法，是希望通过判断Student的属性，比如学生id之类的键值属性是否相等或者多个组合属性（姓名、班级、年龄等等）是否相等来判断是否同一对象。否则只会判断两个Student是否存储地址相等来判断是否同一对象。