java编写salary函数_完美重写Java的equals函数

最新推荐文章于 2022-10-08 18:27:16 发布

焕景

最新推荐文章于 2022-10-08 18:27:16 发布

阅读量415

点赞数

文章标签： java编写salary函数

本文链接：https://blog.csdn.net/weixin_30741979/article/details/114614419

版权

首先看一下String的equals()函数的重写：

1 /**

2 * Compares this string to the specified object. The result is {@code

3 * true} if and only if the argument is not {@codenull} and is a {@code

4 * String} object that represents the same sequence of characters as this5 * object.6 *7 *@paramanObject8 * The object to compare this {@codeString} against9 *10 *@return{@codetrue} if the given object represents a {@codeString}11 * equivalent to this string, {@codefalse} otherwise12 *13 *@see#compareTo(String)14 *@see#equalsIgnoreCase(String)15 */

16 public booleanequals(Object anObject) {17 if (this ==anObject) {18 return true;19 }20 if (anObject instanceofString) {21 String anotherString =(String)anObject;22 int n =value.length;23 if (n ==anotherString.value.length) {24 char v1[] =value;25 char v2[] =anotherString.value;26 int i = 0;27 while (n-- != 0) {28 if (v1[i] !=v2[i])29 return false;30 i++;31 }32 return true;33 }34 }35 return false;36 }

分析一下上面equals()函数：

(1) 首先比较两个对象的引用是否相等，如果两个引用相等，那么两个对象必然相等。

(2) 其次判断anObject是否是String的一个实例 (instanceof关键字的作用是测试一个对象是否是一个类的实例)，如果不是则返回false，如果是，则判断obObject的字符串内容是否和this相同：长度是否相等，内容是否相等。

ps: 使用instanceof关键字的问题：当类A是类B的子类时，使用instanceof关键字重写equals()函数就会不符合java语言规范要求equals()方法的“对称性”特性的要求。对称性(对于任何引用x,y，当且仅当y.equals(x)返回true, x.equals(y)也应该返回true)。

一般我们在设计一个类时，需要重写父类的equals方法，在重写这个方法时，需要按照以下几个规则设计：

(1) 自反性：对任意引用值x，x.equals(x)的返回值一定为true.

(2) 对称性：对于任何引用值x,y,当且仅当y.equals(x)返回值为true时，x.equals(y)的返回值一定为true;

(3) 传递性：如果x.equals(y)=true, y.equals(z)=true,则x.equals(z)=true

(4) 一致性：如果参与比较的对象没任何改变，则对象比较的结果也不应该有任何改变

(5) 非空性：任何非空的引用值X，x.equals(null)的返回值一定为false

那么如何编写一个完美的equals方法呢？

(1)显式参数命名为otherObject，稍后需要将它转换成另一个叫做other的变量。

(2)检测this与otherObject是否引用同一个对象：

if(this== otherObject) return true;

(3)检测otherObject是否为null，如果为null，返回false：

if(otherObject == null) return false;

(4)比价this与otherObject是否属于同一个类。

如果equals的语义在每个子类中有所改变，就使用getClass检测： if(getClass() != otherObject.getClass()) return false;

如果所有的子类都拥有统一的语义，就使用instanceof检测： if(!(otherObject instanceof ClassName)) return false;

(5) 将otherObject转换为相应的类类型变量：

ClassName other = (ClassName) otherObject;

(6)现在开始对所有需要比较的域进行比较。使用==比较基本类型域，使用equals比较对象域。如果所有的域都匹配，就返回true，否则就返回flase。

return field1 ==other.field1&&Objects.equals(field2,other.field2)&& ...;

(7)如果在子类中重新定义equals，就要在其中包含调用 super.equals(other)

举例(摘自Java核心技术)

父类：

1 packageequals;2

3 import java.time.*;4 importjava.util.Objects;5

6 public classEmployee7 {8 privateString name;9 private doublesalary;10 privateLocalDate hireDay;11

12 public Employee(String name, double salary, int year, int month, intday)13 {14 this.name =name;15 this.salary =salary;16 hireDay =LocalDate.of(year, month, day);17 }18

19 publicString getName()20 {21 returnname;22 }23

24 public doublegetSalary()25 {26 returnsalary;27 }28

29 publicLocalDate getHireDay()30 {31 returnhireDay;32 }33

34 public void raiseSalary(doublebyPercent)35 {36 double raise = salary * byPercent / 100;37 salary +=raise;38 }39

40 public booleanequals(Object otherObject)41 {42 //a quick test to see if the objects are identical

43 if (this == otherObject) return true;44

45 //must return false if the explicit parameter is null

46 if (otherObject == null) return false;47

48 //if the classes don't match, they can't be equal

49 if (getClass() != otherObject.getClass()) return false;50

51 //now we know otherObject is a non-null Employee

52 Employee other =(Employee) otherObject;53

54 //test whether the fields have identical values

55 return Objects.equals(name, other.name) && salary == other.salary &&Objects.equals(hireDay, other.hireDay);56 }57

58 public inthashCode()59 {60 returnObjects.hash(name, salary, hireDay);61 }62

63 publicString toString()64 {65 return getClass().getName() + "[name=" + name + ",salary=" + salary + ",hireDay=" +hireDay66 + "]";67 }68 }

子类：

1 packageequals;2

3 public class Manager extendsEmployee4 {5 private doublebonus;6

7 public Manager(String name, double salary, int year, int month, intday)8 {9 super(name, salary, year, month, day);10 bonus = 0;11 }12

13 public doublegetSalary()14 {15 double baseSalary = super.getSalary();16 return baseSalary +bonus;17 }18

19 public void setBonus(doublebonus)20 {21 this.bonus =bonus;22 }23

24 public booleanequals(Object otherObject)25 {26 if (!super.equals(otherObject)) return false;27 Manager other =(Manager) otherObject;28 //super.equals checked that this and other belong to the same class

29 return bonus ==other.bonus;30 }31

32 public inthashCode()33 {34 return super.hashCode() + 17 * newDouble(bonus).hashCode();35 }36

37 publicString toString()38 {39 return super.toString() + "[bonus=" + bonus + "]";40 }41 }

注意：如果重新定义equals方法，就必须重新定义hashCode方法，以便用户可以将对象插入到散列表中。

如果不太懂(4)到底说的是神马，请看以下摘抄的一篇博文的部分内容,对比instanceof和getClass()的区别，其实getClass会判断实例的类是否相等，而instanceof相等的条件，包括两种情况：(1) 类自身 instanceof 类自身；(2) 子类 instanceof 父类；

1 classA { }2

3 class B extendsA { }4

5 Object o1 = newA();6 Object o2 = newB();7

8 o1 instanceof A => true

9 o1 instanceof B => false

10 o2 instanceof A => true //<================ HERE

11 o2 instanceof B => true //<================ HERE

13 o1.getClass().equals(A.class) => true

14 o1.getClass().equals(B.class) => false

15 o2.getClass().equals(A.class) => false //<===============HERE

16 o2.getClass().equals(B.class) => true //<================ HERE

20 getClass() will be useful when you want to make sure your instance is NOT a subclass of the class you are comparing with.