DthingApi: java.lang.Object Class Reference

method:

  // Use  to avoid accidental overloading.
  &#x0040;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

, you should also override

: 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

method:

  &#x0040;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

implementation, because that silently and non-obviously breaks any future code that does use your type as a hash key. You should throw instead:

  &#x0040;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:

  &#x0040;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

implementation.

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

Constructor & Destructor Documentation

◆ Object()

java.lang.Object.Object ( )

inline

Constructs a new instance of

.

Member Function Documentation

◆ clone()

Object java.lang.Object.clone ( ) throws CloneNotSupportedException

inlineprotected

Creates and returns a copy of this

CloneNotSupportedException

. The default implementation returns a so-called "shallow" copy: It creates a new instance of the same class and then copies the field values (including object references) from this instance to the new instance. A "deep" copy, in contrast, would also recursively clone nested objects. A subclass that needs to implement this kind of cloning should call

super.clone()

to create the new instance and then create deep copies of the nested, mutable objects.

Returns: a copy of this object.

Exceptions

if this object's class does not implement the

Cloneable

interface.

◆ equals()

boolean java.lang.Object.equals ( Object o )

inline

Compares this instance with the specified object and indicates if they are equal. In order to be equal,

o

must represent the same object as this instance using a class-specific comparison. The general contract is that this comparison should be reflexive, symmetric, and transitive. Also, no object reference other than null is equal to null.

The default implementation returns

true

only if

this ==

o

. See Writing a correct equals method if you intend implementing your own

method.

The general contract for the

and hashCode() methods is that if

returns

true

for any two objects, then

hashCode()

must return the same value for these objects. This means that subclasses of

usually override either both methods or neither of them.

Parameters

o	the object to compare this instance with.

Returns: true
if the specified object is equal to this
Object
;
false
otherwise.

See also: hashCode

◆ finalize()

void java.lang.Object.finalize ( ) throws Throwable

inlineprotected

Invoked when the garbage collector has detected that this instance is no longer reachable. The default implementation does nothing, but this method can be overridden to free resources.

Note that objects that override

finalize

are significantly more expensive than objects that don't. Finalizers may be run a long time after the object is no longer reachable, depending on memory pressure, so it's a bad idea to rely on them for cleanup. Note also that finalizers are run on a single VM-wide finalizer thread, so doing blocking work in a finalizer is a bad idea. A finalizer is usually only necessary for a class that has a native peer and needs to call a native method to destroy that peer. Even then, it's better to provide an explicit

close

method (and implement java.io.Closeable), and insist that callers manually dispose of instances. This works well for something like files, but less well for something like a

BigInteger

where typical calling code would have to deal with lots of temporaries. Unfortunately, code that creates lots of temporaries is the worst kind of code from the point of view of the single finalizer thread.

If you must use finalizers, consider at least providing your own java.lang.ref.ReferenceQueue and having your own thread process that queue.

Unlike constructors, finalizers are not automatically chained. You are responsible for calling

super.finalize()

yourself.

Uncaught exceptions thrown by finalizers are ignored and do not terminate the finalizer thread.

See Effective Java Item 7, "Avoid finalizers" for more.

◆ getClass()

final native Class<?> java.lang.Object.getClass ( )

Returns the unique instance of Class that represents this object's class. Note that

getClass()

is a special case in that it actually returns

Class<? extends Foo>

where

Foo

is the erasure of the type of the expression

getClass()

was called upon.

As an example, the following code actually compiles, although one might think it shouldn't:

List<Integer> l = new ArrayList<Integer>();
Class<? extends List> c = l.getClass();

Returns: this object's
Class
instance.

◆ hashCode()

native int java.lang.Object.hashCode ( )

Returns an integer hash code for this object. By contract, any two objects for which equals returns

true

must return the same hash code value. This means that subclasses of

usually override both methods or neither method.

Note that hash values must not change over time unless information used in equals comparisons also changes.

See Writing a correct hashCode method if you intend implementing your own