Date post: | 09-May-2015 |
Category: |
Technology |
Upload: | sandeep-chawla |
View: | 946 times |
Download: | 3 times |
Methods Common to All Objects
MANISH ADLAKHA
All methods of Object class have explicit general contracts because they are meant to be overridden.
When a class overrides these methods, the contracts must be obeyed otherwise the classes dependent on these contracts will not function properly.
Methods of object class• equals()• hashCode() • toString()• clone()• finalize()
Object class methods
ITEM 8Obey the general contract when
overriding equals
When a class has a notion of logical equality which extends mere object identity
And the behavior is not by a superclass Need to find whether they are logically
equivalent and not whether they refer to same object
Allows instances to serve as map keys and show set behavior
When to implement equals()
Equivalence relation Reflexive – x.equals(x) -> true Symmetric –
x.equals(y) -> true => y.equals(x) -> true Transitive Consistent -> should return same values
consistently when equals is called For a not-null reference, x.equals(null) ->
false
General contract
Use the == operator to check if the argument is a reference to this object
Use the instanceof operator to check if the argument has the correct type
Cast the argument to the correct type For each significant field in the class, check if that field
of the argument matches the corresponding field of this object
When you are finished writing, ask yourself three questions:
• Is it symmetric?• Is it transitive?• Is it consistent?
How to implement a good quality equals() method
Item 9Always override hashCode when you
override equals
You must override hashCode in every class that overrides equals.
Failure to do so results in violation of the general contract for Object.hashCode, which prevents the class from functioning properly in conjunction with all hash-based collections, including HashMap, HashSet, and Hashtable.
When invoked on an object more than once, hashCode() must consistently return the same integer, provided no information used in equals comparisons on the object is modified
If two objects are equal according to the equals(Object) method, then calling the hashCode method on each of the two objects must produce the same integer result.
Not necessary that hashCode() called on two unequal objects return distinct hashcode numbers but doing so improves the performance of hashtables.
General contract
The key provision that is violated when you fail to override hashCode is the second one: equal objects must have equal hash codes.
We may exclude redundant fields from the hashCode computation.
Do not be tempted to exclude significant parts of an object from the hash code computation to improve performance.
Key points
Item 10Always override toString()
Default return - class name followed by an “at” sign (@) and the unsigned hexadecimal representation of the hash code, for example, “PhoneNumber@163b91
General contract• returned string should be “a concise but informative
representation that is easy for a person to read”
toString()
providing a good toString() implementation makes your class much more pleasant to use.
toString() invoked when an object is◦ Passed to println() and printf()◦ Used in string concatenation operator or assert◦ Printed by the debugger
When practical, the toString method should return all of the interesting information contained in the object
Whether or not you decide to specify the format, you should clearly document your intentions
provide programmatic access to all of the information contained in the value returned by toString()
Item 11Override clone() judiciously
A flag interface that advertises that an object permits cloning
Lacks a clone() method Object class’ clone() is protected -> so cannot be used
without using reflection Cloneable interface determines the behavior of Object’s
clone() implementation It modifies the behavior of a protected method on a
superclass
Cloneable Interface
x.clone() !=x x.clone().getclass() == x.getclass() x.clone().equals(x) should be true but it is not an
absolute requirement No constructors are to be called when creating a
clone
General contract
If you override the clone method in a nonfinal class, you should return an object obtained by invoking super.clone().
In practice, a class that implements Cloneable is expected to provide a properly functioning public clone method.
In effect, the clone method should function as another constructor; you must ensure that it does no harm to the original object and that it properly establishes invariants on the clone
The clone architecture is incompatible with normal use of final fields referring to mutable objects
Key points
Item 12Consider implementing Comparable
Method of the comparable interface Not declared in Object class Allows order comparison along with equality comparisons Indicates a natural ordering of instances of a class
compareTo()
sgn(x.compareTo(y)) == -sgn(y.compareTo(x)) for all x and y
(x.compareTo(y) > 0 && y.compareTo(z) > 0) implies x.compareTo(z) > 0
x.compareTo(y) == 0 implies that sgn(x.compareTo(z)) == sgn(y.compareTo(z)), for all z
(x.compareTo(y) == 0) == (x.equals(y)) – Strongly recommended but not strictly required
General contract
Violating the compareTo() contract breaks the classes dependent on comparison◦ Sorted collections – TreeSet and TreeMap◦ Utility classes collections and Arrays