Java教程6：实用的标准方法、访问修饰符和抽象类

equals（）和hashCode（）

equals（）是一个将你的对象与另一个对象进行比较的方法，只有当它与另一个对象“equal”时才返回true。我们所说的“equal”是什么意思？

在Java中，如果要检查两个对象是否相等，通常会使用==操作符。但实际上，这会检查对对象的两个引用是否指向同一个对象。

这里有一个例子。

class Machine {
    private String name;
    
    public Machine(String name) {
        this.name = name;
    }
    
    public String toString() {
        return "Machine name: " + name;
    }
}

public class Application {
    public static void main(String[] args) {
        
        Machine machine1 = new Machine("Big machine");
        Machine machine2 = new Machine("Big machine");
        Machine machine3 = machine2;
        
        if(machine1 == machine2) {
            System.out.println("Machine1 equals Machine2");
        }
        else {
            System.out.println("Machine1 does not equal Machine2");
        }
        
        if(machine2 == machine3) {
            System.out.println("Machine2 equals Machine3");
        }
        else {
            System.out.println("Machine2 does not equal Machine3");
        }
        
    }
}

Machine1 does not equal Machine2
Machine2 equals Machine3

您可以看到，只有当两个变量指向同一对象时，==才认为它们相等。

然而，我们经常想知道两个对象在它们所表示的内容方面是否等价。

例如，在上面的示例中，Machine1和Machine2都是Machine类型的对象；更重要的是，它们都包含完全相同的数据–它们的名称实例变量被设置为相同的内容，并且它们不包含其他实例变量。它们不是同一个对象，但这两个对象在行为和内在状态方面是相同的。

这就是equals（）的作用。我们重写equals（），这样如果两个不同的对象是等价的，它就会返回true。在这种情况下，如果两台机器具有相同的名称，我们可以通过返回true来实现这一点。

最简单的方法是让IDE实现equals（）。您所要做的就是在测试相等性时选择您认为重要的实例变量。同时，您可以让它实现hashCode（）方法。理想情况下，无论何时实现equals（），都应该实现hashCode（）。hashCode（）的功能是返回一个整数，当两个对象等价时，该整数相同，但当它们不等价时，该整数不同。

在Eclipse中，您可以通过右键单击，选择“Source”，然后选择“Generate hashCode（）and equals（）”来实现这两个方法。然后，您所要做的就是在测试相等性时选择对您重要的实例变量。Eclipse将为您生成一个优化的equals（）方法。如果添加更多重要的实例变量，请不要忘记删除它并重新生成它。

仅当您将对象添加到Map（我们尚未介绍）时才使用hashCode（）。如果你完全确定你永远不会把你的对象添加到Map中，你就不用担心了。但最好是让IDE为您生成它。

在下面的代码中，我们自动添加了equals（）和hashCode（）方法，并使用它们代替==来测试对象是否相等。请注意，M

class Machine {
    private String name;
    
    public Machine(String name) {
        this.name = name;
    }
    
    public String toString() {
        return "Machine name: " + name;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Machine other = (Machine) obj;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }
    
    
}

public class Application {
    public static void main(String[] args) {
        
        Machine machine1 = new Machine("Big machine");
        Machine machine2 = new Machine("Big machine");
        Machine machine3 = machine2;
        
        if(machine1.equals(machine2)) {
            System.out.println("Machine1 equals Machine2");
        }
        else {
            System.out.println("Machine1 does not equal Machine2");
        }
        
        if(machine2.equals(machine3)) {
            System.out.println("Machine2 equals Machine3");
        }
        else {
            System.out.println("Machine2 does not equal Machine3");
        }
        
    }
}

Machine1 equals Machine2
Machine2 equals Machine3

class Machine {
    private String name;
    
    public Machine(String name) {
        this.name = name;
    }
    
    public String toString() {
        return "Machine name: " + name;
    }
    
    @Override 
    public Object clone() {
        return new Machine(name);
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Machine other = (Machine) obj;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }
    
    
}

public class Application {
    public static void main(String[] args) {
        
        Machine machine1 = new Machine("New Machine");
        Machine machine2 = (Machine)machine1.clone();
        
        if(machine1.equals(machine2)) {
            System.out.println("Machine1 equals Machine2");
        }
        else {
            System.out.println("Machine1 does not equal Machine2");
        }
        
        if(machine1 == machine2) {
            System.out.println("machine1 and machine2 point to the same objects");
        }
        else {
            System.out.println("machine1 and machine2 point to different objects");
        }
        
    }
}

Machine1 equals Machine2
machine1 and machine2 point to different objects

class Machine {
    private String name;
    
    public Machine(String name) {
        this.name = name;
    }
    
    public String toString() {
        return "Machine name: " + name;
    }
    
    // Make use of return type covariance.
    // This is still a legitimate override.
    @Override 
    public Machine clone() {
        return new Machine(name);
    }   
}

public class Application {
    public static void main(String[] args) {
        
        Machine machine1 = new Machine("New Machine");
        Machine machine2 = machine1.clone();
        
    }
}

// The Machine class is declare abstract
// because it has an abstract method.
// It now can't be instantiated.
abstract class Machine {
    private String name;
    
    public Machine(String name) {
        this.name = name;
    }
    
    public String toString() {
        return "Machine name: " + name;
    }

    // The abstract method must be overridden
    // in child classes, or else they too
    // must be declared abstract and you can't
    // create objects from them.
    abstract public void start();
}

class Car extends Machine {
    public Car(String name) {
        super(name);
    }
    
    @Override
    public void start() {
        System.out.println("Starting the car.");
    }
}

public class Application {
    public static void main(String[] args) {
        
        // We cannot do the following, because
        // Machine is abstract.
        //Machine machine = new Machine("A machine");
        
        Car car = new Car("A car");
        
        car.start();
        
    }
}

Starting the car.