1.equal方法
Object类中的equal方法用于检测一个对象是否等于另外一个对象。在Object类中，这个方法将判断两个对象是否具有相同的引用。如果两个对象具有相同的引用，它们一定是相等的。然而对于多数类来说，这种判断并没有什么意义，因为经常需要检测两个对象状态是否相等，如果两个对象的状态相等，就认为这两个状态是相等的。
先来看一下Object类中的equals方法的源码：
* @param a an object
* @param b an object to be compared with {@code a} for equality
* @return {@code true} if the arguments are equal to each other
* and {@code false} otherwise
* @see Object#equals(Object)
*/
public static boolean equals(Object a, Object b) {
return (a == b) || (a != null && a.equals(b));
}
通过@see这个注释，再去看一下调用的equals方法
* @param obj the reference object with which to compare.
* @return {@code true} if this object is the same as the obj
* argument; {@code false} otherwise.
* @see #hashCode()
* @see java.util.HashMap
*/
public boolean equals(Object obj) {
return (this == obj);
}
下面有一个实际的例子，Employee类是Manager类的父类，那么根据现实中的情况，如何判断两个雇员是否相等呢，那肯定是如果两个雇员对象的姓名、薪水和雇佣日期都一样，就认为他们是相等的。（为什么不会有同年同月同日...你是个杠精把）
看一下Employee类中判断两个雇员是否相等的方法：
public boolean equals(Object otherObject)
{
// a quick test to see if the objects are identical
if (this == otherObject) return true;
// must return false if the explicit parameter is null
if (otherObject == null) return false;
// if the classes don't match, they can't be equal
if (getClass() != otherObject.getClass()) return false;
// now we know otherObject is a non-null Employee
Employee other = (Employee) otherObject;
// test whether the fields have identical values
return Objects.equals(name, other.name) && salary == other.salary && Objects.equals(hireDay, other.hireDay);
}如果这两个对象相等，那么肯定相等。如果传进来的对象变量为null，那么肯定不相等。如果两个对象不属于同一个类，那么肯定不相等。最后一种情况就很关键了，可能会有两个对象变量的name和hireDay都为null的情况，这个时候就需要调用Object的equals方法了，通过源码可以看出，
- 如果两个对象变量的name或hireDay都为null，则调用Objects.equals方法会返回true，
- 如果其中只有一个对象变量的name或hireDay为null，即Objects.equals(a, b)中只有一个为null，那直接返回false
- 如果两个对象变量的name或hireDay都不为null，即Objects.equals(a, b)中两个都不为null，这时根据return (a == b) || (a != null && a.equals(b));可以知道需要调用a.equals(b)方法判断两个域是否相等。
子类Manager类中的equals方法为：即如果父类的equals方法检测不相等，那么对象就不可能相等。如果父类中的域都相等，就继续检测子类中的实例域。
public boolean equals(Object otherObject)
{
if (!super.equals(otherObject)) return false;
Manager other = (Manager) otherObject;
// super.equals checked that this and other belong to the same class
return bonus == other.bonus;
}测试代码和输出：
public static void main(String[] args)
{
Employee alice1 = new Employee("Alice Adams", 75000, 1987, 12, 15);
Employee alice2 = alice1;
Employee alice3 = new Employee("Alice Adams", 75000, 1987, 12, 15);
Employee bob = new Employee("Bob Brandson", 50000, 1989, 10, 1);
System.out.println("alice1 == alice2: " + (alice1 == alice2));
System.out.println("alice1 == alice3: " + (alice1 == alice3));
System.out.println("alice1.equals(alice3): " + alice1.equals(alice3));
System.out.println("alice1.equals(bob): " + alice1.equals(bob));
Manager carl = new Manager("Carl Cracker", 80000, 1987, 12, 15);
Manager boss = new Manager("Carl Cracker", 80000, 1987, 12, 15);
boss.setBonus(5000);
System.out.println("carl.equals(boss): " + carl.equals(boss));
}
输出为：
alice1 == alice2: true
alice1 == alice3: false
alice1.equals(alice3): true
alice1.equals(bob): false
carl.equals(boss): falseif (getClass() != otherObject.getClass()) return false;来判断，如果两个对象不在一个类中，那么就判断称这两个对象不相等。但是如果两个参数不属于同一个类，该如何处理呢，如果修改成if (!otherObject instanceof Employee) return false;（A instance B的意思是，如果A是B的一个实例或B的子类的一个实例，就返回true，否则返回false）这样的话如果要满足对称性的要求的话会有一些问题，例如，e.equals(m)中的e是一个Employee对象，m是一个Manager对象，并且两个对象具有相同的姓名、薪水和雇佣日期，如果在Employee.equals中调用instanceof检测，则返回true，这没问题。但是如果要反过来的话，如果要让m.equals(e)也返回true，这就要求Manager类的equals方法必须能够用自己与任何一个Employee对象进行比较，然而Manager类的对象还具有Employee类的对象没有的独特的实例域，这就使得使用instanceof出现了问题。
为了解决这个问题，可以从两个方面考虑：（1）如果子类能够拥有自己的相等概念，则对称性需求将强制采用getClass进行检测。（2）如果由父类决定相等的概念，那么就可以使用instanceof进行检测，这样可以在不同子类的对象之间进行相等的比较。
例如：如果两个Manager对象所对应的姓名、薪水和雇佣日期均相等，但是奖金不相等，就认为它们不相同，因此，可以使用getClass检测。如果使用雇员的ID作为相等检测的标准，并且这个相等的概念适用于所有的子类，就可以使用instanceof检测，并应该将Employee.equals声明为final。
Java语言规范要求equals方法应该具有如下特性：
- 自反性：对于任何非空引用x，x.equals(x)应该返回true
- 对称性：对于任何引用x和y，当且仅当y.equals(x)返回true，x.equals(y)也应该返回true
- 传递性：对于任何引用x和y，如果x.equals(y)返回true，y.equals(z)返回true，则x.equals(z)也应该返回ture
- 一致性：如果x和y引用的对象没有发生变化，反复调用x.equals(y)应该返回同样的结果
- 对于任意非空引用x，x.equals(null)应该返回false
一个完美的equals方法应该这样编写:
（1）显示参数命名为otherObject
otherObject) return true;
otherObject是否为空：if(otherObject == null) return false;
otherObject是否属于同一个类：
- 如果equals的语义在每个子类中有所改变，就是用getClass检测：if (getClass() != otherObject.getClass()) return false;
- 如果所有的子类都拥有统一的语义，就是用instanceof检测：if(!otherObject
otherObject转换成相应的类类型变量：ClassName other = （ClassName）otherObject
（6）对所有需要比较的域进行比较，使用“==”比较基本类型域，使用Object.equals方法比较对象域，如果所有的域都匹配，就返回true，否则，返回false
（7）如果需要在子类中重新定义equals，要先调用父类的equals方法super.equals()
2.hashCode方法
散列码（Hash Code）是由对象导出的一个整型值。散列码是没有规律的，如果x和y是两个不同的对象，x.hashCode()与y.hashCode()基本上不会相同。
这里必须强调的是：equals方法和hashCode的定义必须一致：如果x.equals(y)返回true，那么x.hashCode()和y.hashCode()必须相等。
在Employee类中使用下面的代码计算对象的hashCode值：为了实现两个对象如果姓名、薪水和雇佣日期都相等那么这两个对象相等，可以按照下面的 方法得到hashCode值，这里是因为相同字符串拥有相同的散列码，因为字符串的散列码是由内容导出的，有相同的计算公式。
public int hashCode()
{
return Objects.hash(name, salary, hireDay);
}Objects.hash方法会对各个参数调用hashCode方法，并组合这些散列值。
子类Manager类中的hashCode方法：
public int hashCode()
{
return java.util.Objects.hash(super.hashCode(), bonus);
}
测试代码和输出：
public static void main(String[] args)
{
Employee alice1 = new Employee("Alice Adams", 75000, 1987, 12, 15);
Employee alice2 = alice1;
Employee alice3 = new Employee("Alice Adams", 75000, 1987, 12, 15);
Employee bob = new Employee("Bob Brandson", 50000, 1989, 10, 1);
Manager carl = new Manager("Carl Cracker", 80000, 1987, 12, 15);
Manager boss = new Manager("Carl Cracker", 80000, 1987, 12, 15);
boss.setBonus(5000);
System.out.println("alice1.hashCode(): " + alice1.hashCode());
System.out.println("alice3.hashCode(): " + alice3.hashCode());
System.out.println("bob.hashCode(): " + bob.hashCode());
System.out.println("carl.hashCode(): " + carl.hashCode());
}
输出：
alice1.hashCode(): -808853550
alice3.hashCode(): -808853550
bob.hashCode(): -624019882
carl.hashCode(): -20046994363.toString方法
Object中的toString方法用于返回表示对象值的字符串。
例如：
Employee中的toString方法：
public String toString()
{
return getClass().getName() + "[name=" + name + ",salary=" + salary + ",hireDay=" + hireDay
+ "]";
}
子类Manager中的toString方法：
public String toString()
{
return super.toString() + "[bonus=" + bonus + "]";
}测试和输出：
public static void main(String[] args)
{
Employee bob = new Employee("Bob Brandson", 50000, 1989, 10, 1);
System.out.println("bob.toString(): " + bob);
Manager boss = new Manager("Carl Cracker", 80000, 1987, 12, 15);
boss.setBonus(5000);
System.out.println("boss.toString(): " + boss);
}
}
输出：
bob.toString(): aaaaTest.Employee[name=Bob Brandson,salary=50000.0,hireDay=1989-10-01]
boss.toString(): aaaaTest.Manager[name=Carl Cracker,salary=80000.0,hireDay=1987-12-15][bonus=5000.0]
