JDK8-Object源码，java面试算法大全

• The {@code equals} method for class {@code Object} implements

• the most discriminating【差别】 possible equivalence relation on objects;

• that is, for any non-null reference values {@code x} and

• {@code y}, this method returns {@code true} if and only

• if {@code x} and {@code y} refer to the same object

• ({@code x == y} has the value {@code true}).

• Note that it is generally necessary to override the {@code hashCode}

• method whenever this method is overridden, so as to maintain the

• general contract for the {@code hashCode} method, which states

• that equal objects must have equal hash codes.

• @param obj the reference object with which to compare.

• @return {@code true} if this object is the same as the obj

•      argument; {@code false} otherwise.
  

• @see #hashCode()

• @see java.util.HashMap

• */

  public boolean equals(Object obj) {

  return (this == obj); //判断两个对象是否相等，而==是判断两个两个对象的引用是否相等（或者在一些其他如基本类型中被用来比较两个值是否相等）

  }

  /**

  • Creates and returns a copy of this object. The precise meaning

  • of “copy” may depend on the class of the object. The general

  • intent【目的】 is that, for any object {@code x}, the expression:

  • x.clone() != x

  • will be true, and that the expression:

  • x.clone().getClass() == x.getClass()

  • will be {@code true}, but these are not absolute requirements.

  • While it is typically the case that:

  • x.clone().equals(x)

  • will be {@code true}, this is not an absolute requirement.

  • By convention【约定】, the returned object should be obtained by calling

  • {@code super.clone}. If a class and all of its superclasses (except

  • {@code Object}) obey【服从】 this convention, it will be the case that

  • {@code x.clone().getClass() == x.getClass()}.

  • By convention, the object returned by this method should be independent

  • of this object (which is being cloned). To achieve this independence,

  • it may be necessary to modify one or more fields of the object returned

  • by {@code super.clone} before returning it. Typically, this means

  • copying any mutable【易变的】 objects that comprise【由…组成】 the internal “deep structure”

  • of the object being cloned and replacing the references to these

  • objects with references to the copies. If a class contains only

  • primitive fields or references to immutable objects, then it is usually

  • the case that no fields in the object returned by {@code super.clone}

  • need to be modified.

  • The method {@code clone} for class {@code Object} performs a

  • specific cloning operation. First, if the class of this object does

  • not implement the interface {@code Cloneable}, then a

  • {@code CloneNotSupportedException} is thrown. Note that all arrays

  • are considered to implement the interface {@code Cloneable} and that

  • the return type of the {@code clone} method of an array type {@code T[]}

  • is {@code T[]} where T is any reference or primitive type.

  • Otherwise, this method creates a new instance of the class of this

  • object and initializes all its fields with exactly the contents of

  • the corresponding fields of this object, as if by assignment; the

  • contents of the fields are not themselves cloned. Thus, this method

  • performs a “shallow copy” of this object, not a “deep copy” operation.

  • The class {@code Object} does not itself implement the interface

  • {@code Cloneable}, so calling the {@code clone} method on an object