重写Object类的equal()，hashCode()，toString()方法

以下内容来自Java核心技术1第五章中Object类的介绍

介绍
Object类是所有类的始祖，Java中的每一个类都是由它扩展而来。任何类都是Object类的子类，因此Object类型的变量可以引用任何类型的对象：

Object obj = new Employee("zhi",3500)

如果一个类没有使用extends关键字明确标识继承另外一个类，那么这个类就默认继承 Object类。因此，Object类是 Java 类层中的最高层类，是所有类的超类。换句话说，Java 中任何一个类都是它的子类。由于所有的类都是由 Object类衍生出来的，所以 Object类中的方法适用于所有类。Object类中有几个方法，我们在自定义自己的类是应该去覆盖——equal()，hashCode()，toString()。

equal()方法

Object类中的 equal方法用于检测一个对象是否等于另外一个对象。在 Object类中，这个方法将判断两个对象是否具有相同的引用。如果两个对象具有相同的引用，它们一定是相等的。
从这点上看，将其作为默认操作也是合乎情理的。然而，对于多数类来说，这种判断并没有什么意义。例如，采用这种方式比较两个 PrintStream对象是否相等就完全没有意义。然而，经常需要检测两个对象状态的相等性，如果两个对象的状态相等，就认为这两个对象是相等的。
例如，如果两个雇员对象的姓名、薪水和雇佣日期都一样，就认为它们是相等的（在实际的雇员数据库中，比较ID更有意义。利用下面这个示例演示 equals方法的实现技巧）。

class Employee 
{
	//1，判断俩对象指向的引用是否一样，一样则返回true
	//2，判断是否为null，为null则返回false
	//3，判断是否属于同一个类，不属于则返回false
	//若属于同一个类，则判断域是否一样，一样则认为该对象相等。
	public boolean equals（Object otherObject）
	{
		if (this == otherObject) return true;//两个对象地址相等，== 比较的是对象的内存地址。
		if (otherObject == nul) return false;//对象为空
// if the classes don't match, they cant be equal 
		if (getClass()  != otherObject.getclass()) return false;//两个类是不匹配的,getClass()返回该对象所述的类
		Employee other=（Employee）otherobject
		return name.equals.(other.name) && salary==other.salary && hireDay equals(other.hireDay);//name跟hireDay是String对象，因此使用equal()方法，salary是数值，使用==
		}
}

在子类中定义 equals方法时，首先调用超类的 equals。如果检测失败，对象就不可能相等。
如果超类中的域都相等，就需要比较子类中的实例域。

class Manager extends Employee 
{
	//1，使用超类的equal()方法,判断俩对象超类是否一样
	//2，再判断子类中的域是否也相等。
	public boolean equals（Object otherobject）
	{
		if(super.equals(otherObject)) return false;//如果超类的域都不相等，则直接两对象不相等。
		Manager other = (Manager) otherobject;
		return bonus == other.bonus;
	}
}

书中给出了编写一个完美的equal()方法的建议：

1 显式参数命名为otherObject，稍后需要将它转化成另一个叫做other的变量；
2 检测this与otherObject是否引用同一个对象；
     if(this==otherObject)
     {
            return true;          
	}
3 检测otherObject是否为null，如果是，则返回false，
	if(otherObject==null){
          return false ;
	}
4 比较this和otherObject是否属于同一个类，如果equals的语义在每个子类中有所改变，就是用getClass()方法检测；
	if(getClass()!=otherObject.getClass())
	{	
		return false;
	}

如果所有的子类有统一的语义，则使用instanceof检测；
	if(!(otherObject isntanceof ClassName))
	{
		return false;
	}
5 将otherObject转换成相应的类类型变量；
	ClassName other=(ClassName)otherObject;
6 现在开始对所需要比较的域进行比较，
    (1)使用==比较基本类型域，
    (2)使用equals比较对象域，
如果所有的域都匹配，则返回true，否则返回false。
格式如下：
	return field1==other.field1
	&&Objects.equals(field2,other.field2)
	&&...........;
如果在子类中重新定义了equals，就要在其中包含调用super.equals(other)。
对于数组类型的域，可以使用静态的Arrays.equal()方法检测相应的数组元素是否一样

hashCode()方法

散列码(hash code) 是由对象导出的一个整型值。散列码是没有规律的。如果x和y是两个不同的对象， x.hashCode() 与 y.hashCode() 基本上不会相同(如果两个对象相等，那么它们的hashCode()值一定相同。这里的相等是指，通过equals()比较两个对象时返回true。如果两个对象hashCode()相等，它们并不一定相等。因为在散列表中，hashCode()相等，即两个键值对的哈希值相等。然而哈希值相等，并不一定能得出键值对相等。这就是哈希冲突)。

class Employee 
{	
	public int hashCode()
	{
	return 7*name.hashCode() + 11* new Double(salary).hashCode()+ 13* hireDay.hashCode()
	}
}
改进：使用null安全的方法Objects.hashCode
public int hashCode()
	{
	return 7*Objects.hashCode(name) + 11* new Double(salary).hashCode()+ 13* Objects.hashCode(hireDay)
	}

Equals与 hash Code的定义必须一致：如果 X.equals（y）返回true，那么 x .hashCode（）就必须与y.hashCode（）具有相同的值。例如，如果用定义的 Employee equals比较雇员的ID，那么hashCode方法就需要散列ID，而不是雇员的姓名或存储地址。

toString()方法
在Obec中还有一个重要的方法，就是 toString方法，它用于返回表示对象值的字符串。绝大多数（但不是全部）的 toString方法都遵循这样的格式：类的名字，随后是一对方括号括起来的域值。下面是 Employee类中的 toString方法的实现：

public String toString()
{
	return  getClass().getName()" Emp loyee[name="+ name+" Salary="+ salary+"，hireDay="+ hireDay +"]";
}

当然，设计子类的程序员也应该定义自己的 toString方法，并将子类域的描述添加进去。如果超类使用了 getClass().getName()，那么子类只要调用 super toString() 就可以了。例如，下面是 Manager：类中的 toString方法：
public String toString()
{
return super.toString() + “[bonus=” + bonus +"]";
}

附上employee与manager代码

import java.util.*;

/**
 * This program demonstrates the equals method.
 * @version 1.11 2004-02-21
 * @author Cay Horstmann
 */
public class EqualsTest
{
   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));

      System.out.println("bob.toString(): " + 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("boss.toString(): " + boss);
      System.out.println("carl.equals(boss): " + carl.equals(boss));
      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());
   }
}

class Employee
{
   public Employee(String n, double s, int year, int month, int day)
   {
      name = n;
      salary = s;
      GregorianCalendar calendar = new GregorianCalendar(year, month - 1, day);
      hireDay = calendar.getTime();
   }

   public String getName()
   {
      return name;
   }

   public double getSalary()
   {
      return salary;
   }

   public Date getHireDay()
   {
      return hireDay;
   }

   public void raiseSalary(double byPercent)
   {
      double raise = salary * byPercent / 100;
      salary += raise;
   }

   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 name.equals(other.name) && salary == other.salary && hireDay.equals(other.hireDay);
   }

   public int hashCode()
   {
      return 7 * name.hashCode() + 11 * new Double(salary).hashCode() + 13 * hireDay.hashCode();
   }

   public String toString()
   {
      return getClass().getName() + "[name=" + name + ",salary=" + salary + ",hireDay=" + hireDay
            + "]";
   }

   private String name;
   private double salary;
   private Date hireDay;
}

class Manager extends Employee
{
   public Manager(String n, double s, int year, int month, int day)
   {
      super(n, s, year, month, day);
      bonus = 0;
   }

   public double getSalary()
   {
      double baseSalary = super.getSalary();
      return baseSalary + bonus;
   }

   public void setBonus(double b)
   {
      bonus = b;
   }

   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 int hashCode()
   {
      return super.hashCode() + 17 * new Double(bonus).hashCode();
   }

   public String toString()
   {
      return super.toString() + "[bonus=" + bonus + "]";
   }

   private double bonus;
}