实现.equals（Die aDie）方法和静态变量

Question

I am creating the method .equals(Die aDie) in my program. Do I compare every instance variable including static ones?

Answer 1

boolean equals(Die aDie)

is wrong, classes will call the equals(Object) method and ignore your equals(Die). Also implement the int hashCode() method using the same fields that equals(Object) uses.

 @Override public boolean equals(Object aDie){
     if(aDie == null || aDie.getClass() != Die.class)return false;
     if(aDie == this)return true;
     Die other = (Die)aDie;
     ...   
 }
 @Override public int hashCode(){
     ...
 }

You can ignore static fields since they are the same for every Die.

Answer 2

根据定义，静态变量不是实例变量，因此在同一个类的所有实例中始终相等。

Answer 3

Definitely not the static ones.

Whether you compare all the instance variables depends on what determines the "identity" of your objects, ie when do you consider them equal? This can only be decided in the context of your particular application - we'd need more information.

For example, if you had a class representing books, you might only compare the ISBN number to determine whether two books are the same book, if you just wanted to store metadata about them (title, author). If you merged two such databases, you'd want to eliminate duplicate records.

BUT, if you were implementing a library catalogue of actual physical books, each individual copy is important and different, so you might compare ISBN and copy number. If you merged two libraries, you'd expect to be able to detect duplicate copies.

Answer 4

When a variable is declared with the keyword “static”, its called a “class variable”. All instances share the same copy of the variable (always be equal across all instances of the same class). A class variable can be accessed directly with the class, without the need to create a instance.

Answer 5

You would compare every instance variable.

Static variables are guaranteed to be equal, as they are class-specific, not instance-specific, so you don't have to worry about comparing them.

Answer 6

这没有任何意义，因为你使用equals（）比较实例，因为它们是静态的：你会将它们与自己进行比较？

Answer 7

It is useless to compare static data, as it is shared among all instances of your Die class. But you can compare the various fields by accessing them directly (see example below). Note that if your Die object has complex fields (such as instances of Map , Set , etc), you should also call the equals methods on those objects (again, see example below).

If you want to provide an equals () method, you should override the one provided in the Object class ( equals (Object anOtherObject ), rather than overloading it, or at least make sure you also override equals (Object anOtherObject) to make sure that it returns the correct value too (the default implementation only checks if it's the same instance). And in your method you should then check if anOtherObject is an instance of Die .

Here's an example, assuming that your Die class has 3 fields: String name , int value and Map<Integer> complexField :

public boolean equals (Object anOtherObject) {
    if (anOtherObject == this) {
        return true;
    }

    if (!anOtherObject instanceof Die) {
        return false;
    }

    Die otherDie = (Die) anOtherObject;

    if (this.value != otherDie.value ||
            !this.name.equals (otherDie.name) ||
            !this.complexField.equals (otherDie.complexField)) {
        return false;
    }

    return true;
}

Josh Bloch's " Effective Java " has a very details section on how to correctly implement equals . You should definitely read it.