Object

public class Object

The root class of the Java class hierarchy. All non-primitive types (including arrays) inherit either directly or indirectly from this class.

Writing a correct equals method

Follow this style to write a canonical equals method:

   // Use @Override to avoid accidental overloading.
   @Override public boolean equals(Object o) {
     // Return true if the objects are identical.
     // (This is just an optimization, not required for correctness.)
     if (this == o) {
       return true;
     }

     // Return false if the other object has the wrong type.
     // This type may be an interface depending on the interface's specification.
     if (!(o instanceof MyType)) {
       return false;
     }

     // Cast to the appropriate type.
     // This will succeed because of the instanceof, and lets us access private fields.
     MyType lhs = (MyType) o;

     // Check each field. Primitive fields, reference fields, and nullable reference
     // fields are all treated differently.
     return primitiveField == lhs.primitiveField &&
             referenceField.equals(lhs.referenceField) &&
             (nullableField == null ? lhs.nullableField == null
                                    : nullableField.equals(lhs.nullableField));
   }
 

If you override equals, you should also override hashCode: equal instances must have equal hash codes.

See Effective Java item 8 for much more detail and clarification.

Writing a correct hashCode method

Follow this style to write a canonical hashCode method:

   @Override public int hashCode() {
     // Start with a non-zero constant.
     int result = 17;

     // Include a hash for each field.
     result = 31 * result + (booleanField ? 1 : 0);

     result = 31 * result + byteField;
     result = 31 * result + charField;
     result = 31 * result + shortField;
     result = 31 * result + intField;

     result = 31 * result + (int) (longField ^ (longField >>> 32));

     result = 31 * result + Float.floatToIntBits(floatField);

     long doubleFieldBits = Double.doubleToLongBits(doubleField);
     result = 31 * result + (int) (doubleFieldBits ^ (doubleFieldBits >>> 32));

     result = 31 * result + Arrays.hashCode(arrayField);

     result = 31 * result + referenceField.hashCode();
     result = 31 * result +
         (nullableReferenceField == null ? 0
                                         : nullableReferenceField.hashCode());

     return result;
   }
 

If you don't intend your type to be used as a hash key, don't simply rely on the default hashCode implementation, because that silently and non-obviously breaks any future code that does use your type as a hash key. You should throw instead:

   @Override public int hashCode() {
     throw new UnsupportedOperationException();
   }
 

See Effective Java item 9 for much more detail and clarification.

Writing a useful toString method

For debugging convenience, it's common to override toString in this style:

   @Override public String toString() {
     return getClass().getName() + "[" +
         "primitiveField=" + primitiveField + ", " +
         "referenceField=" + referenceField + ", " +
         "arrayField=" + Arrays.toString(arrayField) + "]";
   }
 

The set of fields to include is generally the same as those that would be tested in your equals implementation.

See Effective Java item 10 for much more detail and clarification.

Public Constructor Summary

Object()
Constructs a new instance of Object.

Public Method Summary

boolean
equals(Object obj)
Compares this instance with the specified object and indicates if they are equal.
final Class<?>
getClass()
Returns the unique instance of Class that represents this object's class.
int
hashCode()
Returns an integer hash code for this object.
final void
notify()